// @(#)root/hist:$Id$
// Author: Rene Brun   26/12/94

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

#include "TROOT.h"
#include "TClass.h"
#include "THashList.h"
#include "TH2.h"
#include "TVirtualPad.h"
#include "TF2.h"
#include "TProfile.h"
#include "TRandom.h"
#include "TMatrixFBase.h"
#include "TMatrixDBase.h"
#include "THLimitsFinder.h"
#include "TError.h"
#include "TMath.h"
#include "TObjString.h"
#include "TVirtualHistPainter.h"


ClassImp(TH2)


//______________________________________________________________________________
//
// Service class for 2-Dim histogram classes
//
//  TH2C a 2-D histogram with one byte per cell (char)
//  TH2S a 2-D histogram with two bytes per cell (short integer)
//  TH2I a 2-D histogram with four bytes per cell (32 bits integer)
//  TH2F a 2-D histogram with four bytes per cell (float)
//  TH2D a 2-D histogram with eight bytes per cell (double)
//


//______________________________________________________________________________
TH2::TH2()
{
   // Constructor.

   fDimension   = 2;
   fScalefactor = 1;
   fTsumwy      = fTsumwy2 = fTsumwxy = 0;
}


//______________________________________________________________________________
TH2::TH2(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                     ,Int_t nbinsy,Double_t ylow,Double_t yup)
     :TH1(name,title,nbinsx,xlow,xup)
{
   // See comments in the TH1 base class constructors.

   fDimension   = 2;
   fScalefactor = 1;
   fTsumwy      = fTsumwy2 = fTsumwxy = 0;
   if (nbinsy <= 0) {Warning("TH2","nbinsy is <=0 - set to nbinsy = 1"); nbinsy = 1; }
   fYaxis.Set(nbinsy,ylow,yup);
   fNcells      = fNcells*(nbinsy+2); // fNCells is set in the TH1 constructor
}


//______________________________________________________________________________
TH2::TH2(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                     ,Int_t nbinsy,Double_t ylow,Double_t yup)
     :TH1(name,title,nbinsx,xbins)
{
   // See comments in the TH1 base class constructors.

   fDimension   = 2;
   fScalefactor = 1;
   fTsumwy      = fTsumwy2 = fTsumwxy = 0;
   if (nbinsy <= 0) {Warning("TH2","nbinsy is <=0 - set to nbinsy = 1"); nbinsy = 1; }
   fYaxis.Set(nbinsy,ylow,yup);
   fNcells      = fNcells*(nbinsy+2); // fNCells is set in the TH1 constructor
}


//______________________________________________________________________________
TH2::TH2(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                     ,Int_t nbinsy,const Double_t *ybins)
     :TH1(name,title,nbinsx,xlow,xup)
{
   // See comments in the TH1 base class constructors.

   fDimension   = 2;
   fScalefactor = 1;
   fTsumwy      = fTsumwy2 = fTsumwxy = 0;
   if (nbinsy <= 0) {Warning("TH2","nbinsy is <=0 - set to nbinsy = 1"); nbinsy = 1; }
   if (ybins) fYaxis.Set(nbinsy,ybins);
   else       fYaxis.Set(nbinsy,0,1);
   fNcells      = fNcells*(nbinsy+2); // fNCells is set in the TH1 constructor
}


//______________________________________________________________________________
TH2::TH2(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                           ,Int_t nbinsy,const Double_t *ybins)
     :TH1(name,title,nbinsx,xbins)
{
   // See comments in the TH1 base class constructors.

   fDimension   = 2;
   fScalefactor = 1;
   fTsumwy      = fTsumwy2 = fTsumwxy = 0;
   if (nbinsy <= 0) {Warning("TH2","nbinsy is <=0 - set to nbinsy = 1"); nbinsy = 1; }
   if (ybins) fYaxis.Set(nbinsy,ybins);
   else       fYaxis.Set(nbinsy,0,1);
   fNcells      = fNcells*(nbinsy+2); // fNCells is set in the TH1 constructor
}


//______________________________________________________________________________
TH2::TH2(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                           ,Int_t nbinsy,const Float_t *ybins)
     :TH1(name,title,nbinsx,xbins)
{
   // See comments in the TH1 base class constructors.

   fDimension   = 2;
   fScalefactor = 1;
   fTsumwy      = fTsumwy2 = fTsumwxy = 0;
   if (nbinsy <= 0) {Warning("TH2","nbinsy is <=0 - set to nbinsy = 1"); nbinsy = 1; }
   if (ybins) fYaxis.Set(nbinsy,ybins);
   else       fYaxis.Set(nbinsy,0,1);
   fNcells      = fNcells*(nbinsy+2); // fNCells is set in the TH1 constructor.
}


//______________________________________________________________________________
TH2::TH2(const TH2 &h) : TH1()
{
   // Copy constructor.
   // The list of functions is not copied. (Use Clone if needed)

   ((TH2&)h).Copy(*this);
}


//______________________________________________________________________________
TH2::~TH2()
{
   // Destructor.
}


//______________________________________________________________________________
Int_t TH2::BufferEmpty(Int_t action)
{
   // Fill histogram with all entries in the buffer.
   // action = -1 histogram is reset and refilled from the buffer (called by THistPainter::Paint)
   // action =  0 histogram is filled from the buffer
   // action =  1 histogram is filled and buffer is deleted
   //             The buffer is automatically deleted when the number of entries
   //             in the buffer is greater than the number of entries in the histogram

   // do we need to compute the bin size?
   if (!fBuffer) return 0;
   Int_t nbentries = (Int_t)fBuffer[0];

   // nbentries correspond to the number of entries of histogram

   if (nbentries == 0) return 0;
   if (nbentries < 0 && action == 0) return 0;    // case histogram has been already filled from the buffer

   Double_t *buffer = fBuffer;
   if (nbentries < 0) {
      nbentries  = -nbentries;
      //  a reset might call BufferEmpty() giving an infinite loop
      // Protect it by setting fBuffer = 0
      fBuffer=0;
       //do not reset the list of functions
      Reset("ICES");
      fBuffer = buffer;
   }

   if (CanExtendAllAxes() || fXaxis.GetXmax() <= fXaxis.GetXmin() || fYaxis.GetXmax() <= fYaxis.GetXmin()) {
      //find min, max of entries in buffer
      Double_t xmin = fBuffer[2];
      Double_t xmax = xmin;
      Double_t ymin = fBuffer[3];
      Double_t ymax = ymin;
      for (Int_t i=1;i<nbentries;i++) {
         Double_t x = fBuffer[3*i+2];
         if (x < xmin) xmin = x;
         if (x > xmax) xmax = x;
         Double_t y = fBuffer[3*i+3];
         if (y < ymin) ymin = y;
         if (y > ymax) ymax = y;
      }
      if (fXaxis.GetXmax() <= fXaxis.GetXmin() || fYaxis.GetXmax() <= fYaxis.GetXmin()) {
         THLimitsFinder::GetLimitsFinder()->FindGoodLimits(this,xmin,xmax,ymin,ymax);
      } else {
         fBuffer = 0;
         Int_t keep = fBufferSize; fBufferSize = 0;
         if (xmin <  fXaxis.GetXmin()) ExtendAxis(xmin,&fXaxis);
         if (xmax >= fXaxis.GetXmax()) ExtendAxis(xmax,&fXaxis);
         if (ymin <  fYaxis.GetXmin()) ExtendAxis(ymin,&fYaxis);
         if (ymax >= fYaxis.GetXmax()) ExtendAxis(ymax,&fYaxis);
         fBuffer = buffer;
         fBufferSize = keep;
      }
   }

   fBuffer = 0;
   for (Int_t i=0;i<nbentries;i++) {
      Fill(buffer[3*i+2],buffer[3*i+3],buffer[3*i+1]);
   }
   fBuffer = buffer;

   if (action > 0) { delete [] fBuffer; fBuffer = 0; fBufferSize = 0;}
   else {
      if (nbentries == (Int_t)fEntries) fBuffer[0] = -nbentries;
      else                              fBuffer[0] = 0;
   }
   return nbentries;
}


//______________________________________________________________________________
Int_t TH2::BufferFill(Double_t x, Double_t y, Double_t w)
{
   // accumulate arguments in buffer. When buffer is full, empty the buffer
   // fBuffer[0] = number of entries in buffer
   // fBuffer[1] = w of first entry
   // fBuffer[2] = x of first entry
   // fBuffer[3] = y of first entry

   if (!fBuffer) return -3;
   Int_t nbentries = (Int_t)fBuffer[0];
   if (nbentries < 0) {
      nbentries  = -nbentries;
      fBuffer[0] =  nbentries;
      if (fEntries > 0) {
         Double_t *buffer = fBuffer; fBuffer=0;
         Reset("ICES");
         fBuffer = buffer;
      }
   }
   if (3*nbentries+3 >= fBufferSize) {
      BufferEmpty(1);
      return Fill(x,y,w);
   }
   fBuffer[3*nbentries+1] = w;
   fBuffer[3*nbentries+2] = x;
   fBuffer[3*nbentries+3] = y;
   fBuffer[0] += 1;
   return -3;
}


//______________________________________________________________________________
void TH2::Copy(TObject &obj) const
{
   // Copy.

   TH1::Copy(obj);
   ((TH2&)obj).fScalefactor = fScalefactor;
   ((TH2&)obj).fTsumwy      = fTsumwy;
   ((TH2&)obj).fTsumwy2     = fTsumwy2;
   ((TH2&)obj).fTsumwxy     = fTsumwxy;
}


//______________________________________________________________________________
Int_t TH2::Fill(Double_t )
{
   // Invalid Fill method.

   Error("Fill", "Invalid signature - do nothing");
   return -1;
}


//______________________________________________________________________________
Int_t TH2::Fill(Double_t x,Double_t y)
{
   // Increment cell defined by x,y by 1.
   //
   // if x or/and y is less than the low-edge of the corresponding axis first bin,
   //   the Underflow cell is incremented.
   // if x or/and y is greater than the upper edge of corresponding axis last bin,
   //   the Overflow cell is incremented.
   //
   // If the storage of the sum of squares of weights has been triggered,
   // via the function Sumw2, then the sum of the squares of weights is incremented
   // by 1 in the cell corresponding to x,y.
   //
   // The function returns the corresponding global bin number which has its content
   // incremented by 1

   if (fBuffer) return BufferFill(x,y,1);

   Int_t binx, biny, bin;
   fEntries++;
   binx = fXaxis.FindBin(x);
   biny = fYaxis.FindBin(y);
   if (binx <0 || biny <0) return -1;
   bin  = biny*(fXaxis.GetNbins()+2) + binx;
   AddBinContent(bin);
   if (fSumw2.fN) ++fSumw2.fArray[bin];
   if (binx == 0 || binx > fXaxis.GetNbins()) {
      if (!fgStatOverflows) return -1;
   }
   if (biny == 0 || biny > fYaxis.GetNbins()) {
      if (!fgStatOverflows) return -1;
   }
   ++fTsumw;
   ++fTsumw2;
   fTsumwx  += x;
   fTsumwx2 += x*x;
   fTsumwy  += y;
   fTsumwy2 += y*y;
   fTsumwxy += x*y;
   return bin;
}


//______________________________________________________________________________
Int_t TH2::Fill(Double_t x, Double_t y, Double_t w)
{
   // Increment cell defined by x,y by a weight w.
   //
   // if x or/and y is less than the low-edge of the corresponding axis first bin,
   //   the Underflow cell is incremented.
   // if x or/and y is greater than the upper edge of corresponding axis last bin,
   //   the Overflow cell is incremented.
   //
   //  If the weight is not equal to 1, the storage of the sum of squares of
   //   weights is automatically triggered and the sum of the squares of weights is incremented
   //   by w^2 in the bin corresponding to x,y
   //
   // The function returns the corresponding global bin number which has its content
   // incremented by w

   if (fBuffer) return BufferFill(x,y,w);

   Int_t binx, biny, bin;
   fEntries++;
   binx = fXaxis.FindBin(x);
   biny = fYaxis.FindBin(y);
   if (binx <0 || biny <0) return -1;
   bin  = biny*(fXaxis.GetNbins()+2) + binx;
   if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW))  Sumw2();   // must be called before AddBinContent
   if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
   AddBinContent(bin,w);
   if (binx == 0 || binx > fXaxis.GetNbins()) {
      if (!fgStatOverflows) return -1;
   }
   if (biny == 0 || biny > fYaxis.GetNbins()) {
      if (!fgStatOverflows) return -1;
   }
   Double_t z= w;
   fTsumw   += z;
   fTsumw2  += z*z;
   fTsumwx  += z*x;
   fTsumwx2 += z*x*x;
   fTsumwy  += z*y;
   fTsumwy2 += z*y*y;
   fTsumwxy += z*x*y;
   return bin;
}


//______________________________________________________________________________
Int_t TH2::Fill(const char *namex, const char *namey, Double_t w)
{
   // Increment cell defined by namex,namey by a weight w
   //
   // if x or/and y is less than the low-edge of the corresponding axis first bin,
   //   the Underflow cell is incremented.
   // if x or/and y is greater than the upper edge of corresponding axis last bin,
   //   the Overflow cell is incremented.
   //
   // If the weight is not equal to 1, the storage of the sum of squares of
   //  weights is automatically triggered and the sum of the squares of weights is incremented
   //  by w^2 in the bin corresponding to namex,namey
   //
   // The function returns the corresponding global bin number which has its content
   // incremented by w

   Int_t binx, biny, bin;
   fEntries++;
   binx = fXaxis.FindBin(namex);
   biny = fYaxis.FindBin(namey);
   if (binx <0 || biny <0) return -1;
   bin  = biny*(fXaxis.GetNbins()+2) + binx;
   if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW))  Sumw2();   // must be called before AddBinContent
   if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
   AddBinContent(bin,w);
   if (binx == 0 || binx > fXaxis.GetNbins()) return -1;
   if (biny == 0 || biny > fYaxis.GetNbins()) return -1;
   Double_t x = fXaxis.GetBinCenter(binx);
   Double_t y = fYaxis.GetBinCenter(biny);
   Double_t z= w;
   fTsumw   += z;
   fTsumw2  += z*z;
   fTsumwx  += z*x;
   fTsumwx2 += z*x*x;
   fTsumwy  += z*y;
   fTsumwy2 += z*y*y;
   fTsumwxy += z*x*y;
   return bin;
}


//______________________________________________________________________________
Int_t TH2::Fill(const char *namex, Double_t y, Double_t w)
{
   // Increment cell defined by namex,y by a weight w
   //
   // if x or/and y is less than the low-edge of the corresponding axis first bin,
   //   the Underflow cell is incremented.
   // if x or/and y is greater than the upper edge of corresponding axis last bin,
   //   the Overflow cell is incremented.
   //
   // If the weight is not equal to 1, the storage of the sum of squares of
   //  weights is automatically triggered and the sum of the squares of weights is incremented
   //  by w^2 in the bin corresponding to namex,y
   //
   // The function returns the corresponding global bin number which has its content
   // incremented by w

   Int_t binx, biny, bin;
   fEntries++;
   binx = fXaxis.FindBin(namex);
   biny = fYaxis.FindBin(y);
   if (binx <0 || biny <0) return -1;
   bin  = biny*(fXaxis.GetNbins()+2) + binx;
   if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW))  Sumw2();   // must be called before AddBinContent
   if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
   AddBinContent(bin,w);
   if (binx == 0 || binx > fXaxis.GetNbins()) return -1;
   if (biny == 0 || biny > fYaxis.GetNbins()) {
      if (!fgStatOverflows) return -1;
   }
   Double_t x = fXaxis.GetBinCenter(binx);
   Double_t z= w; //(w > 0 ? w : -w);
   fTsumw   += z;
   fTsumw2  += z*z;
   fTsumwx  += z*x;
   fTsumwx2 += z*x*x;
   fTsumwy  += z*y;
   fTsumwy2 += z*y*y;
   fTsumwxy += z*x*y;
   return bin;
}


//______________________________________________________________________________
Int_t TH2::Fill(Double_t x, const char *namey, Double_t w)
{
   // Increment cell defined by x,namey by a weight w
   //
   // if x or/and y is less than the low-edge of the corresponding axis first bin,
   //   the Underflow cell is incremented.
   // if x or/and y is greater than the upper edge of corresponding axis last bin,
   //   the Overflow cell is incremented.
   //
   // If the weight is not equal to 1, the storage of the sum of squares of
   //  weights is automatically triggered and the sum of the squares of weights is incremented
   //  by w^2 in the bin corresponding to x,y.
   //
   // The function returns the corresponding global bin number which has its content
   // incremented by w

   Int_t binx, biny, bin;
   fEntries++;
   binx = fXaxis.FindBin(x);
   biny = fYaxis.FindBin(namey);
   if (binx <0 || biny <0) return -1;
   bin  = biny*(fXaxis.GetNbins()+2) + binx;
   if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW))  Sumw2();   // must be called before AddBinContent
   if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
   AddBinContent(bin,w);
   if (binx == 0 || binx > fXaxis.GetNbins()) {
      if (!fgStatOverflows) return -1;
   }
   if (biny == 0 || biny > fYaxis.GetNbins()) return -1;
   Double_t y = fYaxis.GetBinCenter(biny);
   Double_t z= w; //(w > 0 ? w : -w);
   fTsumw   += z;
   fTsumw2  += z*z;
   fTsumwx  += z*x;
   fTsumwx2 += z*x*x;
   fTsumwy  += z*y;
   fTsumwy2 += z*y*y;
   fTsumwxy += z*x*y;
   return bin;
}


//______________________________________________________________________________
void TH2::FillN(Int_t ntimes, const Double_t *x, const Double_t *y, const Double_t *w, Int_t stride)
{
   // Fill a 2-D histogram with an array of values and weights.
   //
   // ntimes:  number of entries in arrays x and w (array size must be ntimes*stride)
   // x:       array of x values to be histogrammed
   // y:       array of y values to be histogrammed
   // w:       array of weights
   // stride:  step size through arrays x, y and w
   //
   //  If the weight is not equal to 1, the storage of the sum of squares of
   //   weights is automatically triggered and the sum of the squares of weights is incremented
   //   by w[i]^2 in the bin corresponding to x[i],y[i].
   //  If w is NULL each entry is assumed a weight=1
   //
   // NB: function only valid for a TH2x object

   Int_t binx, biny, bin, i;
   ntimes *= stride;
   Int_t ifirst = 0;

   //If a buffer is activated, fill buffer
   // (note that this function must not be called from TH2::BufferEmpty)
   if (fBuffer) {
      for (i=0;i<ntimes;i+=stride) {
         if (!fBuffer) break; // buffer can be deleted in BufferFill when is empty
         if (w) BufferFill(x[i],y[i],w[i]);
         else BufferFill(x[i], y[i], 1.);
      }
      // fill the remaining entries if the buffer has been deleted
      if (i < ntimes && fBuffer==0)
         ifirst = i;
      else
         return;
   }

   Double_t ww = 1;
   for (i=ifirst;i<ntimes;i+=stride) {
      fEntries++;
      binx = fXaxis.FindBin(x[i]);
      biny = fYaxis.FindBin(y[i]);
      if (binx <0 || biny <0) continue;
      bin  = biny*(fXaxis.GetNbins()+2) + binx;
      if (w) ww = w[i];
      if (!fSumw2.fN && ww != 1.0 && !TestBit(TH1::kIsNotW))  Sumw2();
      if (fSumw2.fN) fSumw2.fArray[bin] += ww*ww;
      AddBinContent(bin,ww);
      if (binx == 0 || binx > fXaxis.GetNbins()) {
         if (!fgStatOverflows) continue;
      }
      if (biny == 0 || biny > fYaxis.GetNbins()) {
         if (!fgStatOverflows) continue;
      }
      Double_t z= ww; //(ww > 0 ? ww : -ww);
      fTsumw   += z;
      fTsumw2  += z*z;
      fTsumwx  += z*x[i];
      fTsumwx2 += z*x[i]*x[i];
      fTsumwy  += z*y[i];
      fTsumwy2 += z*y[i]*y[i];
      fTsumwxy += z*x[i]*y[i];
   }
}


//______________________________________________________________________________
void TH2::FillRandom(const char *fname, Int_t ntimes)
{
   // Fill histogram following distribution in function fname.
   //
   //   The distribution contained in the function fname (TF2) is integrated
   //   over the channel contents.
   //   It is normalized to 1.
   //   Getting one random number implies:
   //     - Generating a random number between 0 and 1 (say r1)
   //     - Look in which bin in the normalized integral r1 corresponds to
   //     - Fill histogram channel
   //   ntimes random numbers are generated
   //
   //  One can also call TF2::GetRandom2 to get a random variate from a function.

   Int_t bin, binx, biny, ibin, loop;
   Double_t r1, x, y;
   //*-*- Search for fname in the list of ROOT defined functions
   TObject *fobj = gROOT->GetFunction(fname);
   if (!fobj) { Error("FillRandom", "Unknown function: %s",fname); return; }
   TF2 * f1 = dynamic_cast<TF2*>(fobj);
   if (!f1) { Error("FillRandom", "Function: %s is not a TF2",fname); return; }

   // Allocate temporary space to store the integral and compute integral
   Int_t nbinsx = GetNbinsX();
   Int_t nbinsy = GetNbinsY();
   Int_t nbins  = nbinsx*nbinsy;

   Double_t *integral = new Double_t[nbins+1];
   ibin = 0;
   integral[ibin] = 0;
   for (biny=1;biny<=nbinsy;biny++) {
      for (binx=1;binx<=nbinsx;binx++) {
         ibin++;
         Double_t fint = f1->Integral(fXaxis.GetBinLowEdge(binx), fXaxis.GetBinUpEdge(binx), fYaxis.GetBinLowEdge(biny), fYaxis.GetBinUpEdge(biny));
         integral[ibin] = integral[ibin-1] + fint;
      }
   }

   // Normalize integral to 1
   if (integral[nbins] == 0 ) {
      delete [] integral;
      Error("FillRandom", "Integral = zero"); return;
   }
   for (bin=1;bin<=nbins;bin++)  integral[bin] /= integral[nbins];

   // Start main loop ntimes
   for (loop=0;loop<ntimes;loop++) {
      r1 = gRandom->Rndm(loop);
      ibin = TMath::BinarySearch(nbins,&integral[0],r1);
      biny = ibin/nbinsx;
      binx = 1 + ibin - nbinsx*biny;
      biny++;
      x    = fXaxis.GetBinCenter(binx);
      y    = fYaxis.GetBinCenter(biny);
      Fill(x,y);
   }
   delete [] integral;
}


//______________________________________________________________________________
void TH2::FillRandom(TH1 *h, Int_t ntimes)
{
   // Fill histogram following distribution in histogram h.
   //
   //   The distribution contained in the histogram h (TH2) is integrated
   //   over the channel contents.
   //   It is normalized to 1.
   //   Getting one random number implies:
   //     - Generating a random number between 0 and 1 (say r1)
   //     - Look in which bin in the normalized integral r1 corresponds to
   //     - Fill histogram channel
   //   ntimes random numbers are generated

   if (!h) { Error("FillRandom", "Null histogram"); return; }
   if (fDimension != h->GetDimension()) {
      Error("FillRandom", "Histograms with different dimensions"); return;
   }

   if (h->ComputeIntegral() == 0) return;

   Int_t loop;
   Double_t x,y;
   TH2 *h2 = (TH2*)h;
   for (loop=0;loop<ntimes;loop++) {
      h2->GetRandom2(x,y);
      Fill(x,y);
   }
}


//______________________________________________________________________________
Int_t TH2::FindFirstBinAbove(Double_t threshold, Int_t axis) const
{
   // Find first bin with content > threshold for axis (1=x, 2=y, 3=z)
   // if no bins with content > threshold is found the function returns -1.

   if (axis < 1 || axis > 2) {
      Warning("FindFirstBinAbove","Invalid axis number : %d, axis x assumed\n",axis);
      axis = 1;
   }
   Int_t nbinsx = fXaxis.GetNbins();
   Int_t nbinsy = fYaxis.GetNbins();
   Int_t binx, biny;
   if (axis == 1) {
      for (binx=1;binx<=nbinsx;binx++) {
         for (biny=1;biny<=nbinsy;biny++) {
            if (GetBinContent(binx,biny) > threshold) return binx;
         }
      }
   } else {
      for (biny=1;biny<=nbinsy;biny++) {
         for (binx=1;binx<=nbinsx;binx++) {
            if (GetBinContent(binx,biny) > threshold) return biny;
         }
      }
   }
   return -1;
}


//______________________________________________________________________________
Int_t TH2::FindLastBinAbove(Double_t threshold, Int_t axis) const
{
   // Find last bin with content > threshold for axis (1=x, 2=y, 3=z)
   // if no bins with content > threshold is found the function returns -1.

   if (axis < 1 || axis > 2) {
      Warning("FindLastBinAbove","Invalid axis number : %d, axis x assumed\n",axis);
      axis = 1;
   }
   Int_t nbinsx = fXaxis.GetNbins();
   Int_t nbinsy = fYaxis.GetNbins();
   Int_t binx, biny;
   if (axis == 1) {
      for (binx=nbinsx;binx>=1;binx--) {
         for (biny=1;biny<=nbinsy;biny++) {
            if (GetBinContent(binx,biny) > threshold) return binx;
         }
      }
   } else {
      for (biny=nbinsy;biny>=1;biny--) {
         for (binx=1;binx<=nbinsx;binx++) {
            if (GetBinContent(binx,biny) > threshold) return biny;
         }
      }
   }
   return -1;
}


//______________________________________________________________________________
void TH2::DoFitSlices(bool onX,
                      TF1 *f1, Int_t firstbin, Int_t lastbin, Int_t cut, Option_t *option, TObjArray* arr)
{
   TAxis& outerAxis = (onX ? fYaxis : fXaxis);
   TAxis& innerAxis = (onX ? fXaxis : fYaxis);

   Int_t nbins  = outerAxis.GetNbins();
   if (firstbin < 0) firstbin = 0;
   if (lastbin < 0 || lastbin > nbins + 1) lastbin = nbins + 1;
   if (lastbin < firstbin) {firstbin = 0; lastbin = nbins + 1;}
   TString opt = option;
   opt.ToLower();
   Int_t ngroup = 1;
   if (opt.Contains("g2")) {ngroup = 2; opt.ReplaceAll("g2","");}
   if (opt.Contains("g3")) {ngroup = 3; opt.ReplaceAll("g3","");}
   if (opt.Contains("g4")) {ngroup = 4; opt.ReplaceAll("g4","");}
   if (opt.Contains("g5")) {ngroup = 5; opt.ReplaceAll("g5","");}

   // implement option S sliding merge for each bin using in conjunction with a given Gn
   Int_t nstep = ngroup;
   if (opt.Contains("s"))  nstep = 1;

   //default is to fit with a gaussian
   if (f1 == 0) {
      f1 = (TF1*)gROOT->GetFunction("gaus");
      if (f1 == 0) f1 = new TF1("gaus","gaus",innerAxis.GetXmin(),innerAxis.GetXmax());
      else         f1->SetRange(innerAxis.GetXmin(),innerAxis.GetXmax());
   }
   Int_t npar = f1->GetNpar();
   if (npar <= 0) return;
   Double_t *parsave = new Double_t[npar];
   f1->GetParameters(parsave);

   if (arr) {
      arr->SetOwner();
      arr->Expand(npar + 1);
   }

   //Create one histogram for each function parameter
   Int_t ipar;
   TH1D **hlist = new TH1D*[npar];
   char *name   = new char[2000];
   char *title  = new char[2000];
   const TArrayD *bins = outerAxis.GetXbins();
   for (ipar=0;ipar<npar;ipar++) {
      snprintf(name,2000,"%s_%d",GetName(),ipar);
      snprintf(title,2000,"Fitted value of par[%d]=%s",ipar,f1->GetParName(ipar));
      delete gDirectory->FindObject(name);
      if (bins->fN == 0) {
         hlist[ipar] = new TH1D(name,title, nbins, outerAxis.GetXmin(), outerAxis.GetXmax());
      } else {
         hlist[ipar] = new TH1D(name,title, nbins,bins->fArray);
      }
      hlist[ipar]->GetXaxis()->SetTitle(outerAxis.GetTitle());
      if (arr)
         (*arr)[ipar] = hlist[ipar];
   }
   snprintf(name,2000,"%s_chi2",GetName());
   delete gDirectory->FindObject(name);
   TH1D *hchi2 = 0;
   if (bins->fN == 0) {
      hchi2 = new TH1D(name,"chisquare", nbins, outerAxis.GetXmin(), outerAxis.GetXmax());
   } else {
      hchi2 = new TH1D(name,"chisquare", nbins, bins->fArray);
   }
   hchi2->GetXaxis()->SetTitle(outerAxis.GetTitle());
   if (arr)
      (*arr)[npar] = hchi2;

   //Loop on all bins in Y, generate a projection along X
   Int_t bin;
   Long64_t nentries;
   // in case of sliding merge nstep=1, i.e. do slices starting for every bin
   // now do not slices case with overflow (makes more sense)
   for (bin=firstbin;bin+ngroup-1<=lastbin;bin += nstep) {
      TH1D *hp;
      if (onX)
         hp= ProjectionX("_temp",bin,bin+ngroup-1,"e");
      else
         hp= ProjectionY("_temp",bin,bin+ngroup-1,"e");
      if (hp == 0) continue;
      nentries = Long64_t(hp->GetEntries());
      if (nentries == 0 || nentries < cut) {delete hp; continue;}
      f1->SetParameters(parsave);
      hp->Fit(f1,opt.Data());
      Int_t npfits = f1->GetNumberFitPoints();
      if (npfits > npar && npfits >= cut) {
         Int_t binOn = bin + ngroup/2;
         for (ipar=0;ipar<npar;ipar++) {
            hlist[ipar]->Fill(outerAxis.GetBinCenter(binOn),f1->GetParameter(ipar));
            hlist[ipar]->SetBinError(binOn,f1->GetParError(ipar));
         }
         hchi2->SetBinContent(binOn,f1->GetChisquare()/(npfits-npar));
      }
      delete hp;
   }
   delete [] parsave;
   delete [] name;
   delete [] title;
   delete [] hlist;
}


//______________________________________________________________________________
void TH2::FitSlicesX(TF1 *f1, Int_t firstybin, Int_t lastybin, Int_t cut, Option_t *option, TObjArray* arr)
{
   // Project slices along X in case of a 2-D histogram, then fit each slice
   // with function f1 and make a histogram for each fit parameter
   // Only bins along Y between firstybin and lastybin are considered.
   // By default (firstybin == 0, lastybin == -1), all bins in y including
   // over- and underflows are taken into account.
   // If f1=0, a gaussian is assumed
   // Before invoking this function, one can set a subrange to be fitted along X
   // via f1->SetRange(xmin,xmax)
   // The argument option (default="QNR") can be used to change the fit options.
   //     "Q"  means Quiet mode
   //     "N"  means do not show the result of the fit
   //     "R"  means fit the function in the specified function range
   //     "G2" merge 2 consecutive bins along X
   //     "G3" merge 3 consecutive bins along X
   //     "G4" merge 4 consecutive bins along X
   //     "G5" merge 5 consecutive bins along X
   //     "S"  sliding merge: merge n consecutive bins along X accordingly to what Gn is given.
   //          It makes sense when used together with a Gn option
   //
   // The generated histograms are returned by adding them to arr, if arr is not NULL.
   // arr's SetOwner() is called, to signal that it is the user's respponsability to
   // delete the histograms, possibly by deleting the arrary.
   //    TObjArray aSlices;
   //    h2->FitSlicesX(func, 0, -1, 0, "QNR", &aSlices);
   // will already delete the histograms once aSlice goes out of scope. aSlices will
   // contain the histogram for the i-th parameter of the fit function at aSlices[i];
   // aSlices[n] (n being the number of parameters) contains the chi2 distribution of
   // the fits.
   //
   // If arr is NULL, the generated histograms are added to the list of objects
   // in the current directory. It is the user's responsability to delete
   // these histograms.
   //
   //  Example: Assume a 2-d histogram h2
   //   Root > h2->FitSlicesX(); produces 4 TH1D histograms
   //          with h2_0 containing parameter 0(Constant) for a Gaus fit
   //                    of each bin in Y projected along X
   //          with h2_1 containing parameter 1(Mean) for a gaus fit
   //          with h2_2 containing parameter 2(RMS)  for a gaus fit
   //          with h2_chi2 containing the chisquare/number of degrees of freedom for a gaus fit
   //
   //   Root > h2->FitSlicesX(0,15,22,10);
   //          same as above, but only for bins 15 to 22 along Y
   //          and only for bins in Y for which the corresponding projection
   //          along X has more than cut bins filled.
   //
   //  NOTE: To access the generated histograms in the current directory, do eg:
   //     TH1D *h2_1 = (TH1D*)gDirectory->Get("h2_1");

   DoFitSlices(true, f1, firstybin, lastybin, cut, option, arr);

}


//______________________________________________________________________________
void TH2::FitSlicesY(TF1 *f1, Int_t firstxbin, Int_t lastxbin, Int_t cut, Option_t *option, TObjArray* arr)
{
   // Project slices along Y in case of a 2-D histogram, then fit each slice
   // with function f1 and make a histogram for each fit parameter
   // Only bins along X between firstxbin and lastxbin are considered.
   // By default (firstxbin == 0, lastxbin == -1), all bins in x including
   // over- and underflows are taken into account.
   // If f1=0, a gaussian is assumed
   // Before invoking this function, one can set a subrange to be fitted along Y
   // via f1->SetRange(ymin,ymax)
   // The argument option (default="QNR") can be used to change the fit options.
   //     "Q"  means Quiet mode
   //     "N"  means do not show the result of the fit
   //     "R"  means fit the function in the specified function range
   //     "G2" merge 2 consecutive bins along Y
   //     "G3" merge 3 consecutive bins along Y
   //     "G4" merge 4 consecutive bins along Y
   //     "G5" merge 5 consecutive bins along Y
   //     "S"  sliding merge: merge n consecutive bins along Y accordingly to what Gn is given.
   //          It makes sense when used together with a Gn option
   //
   // The generated histograms are returned by adding them to arr, if arr is not NULL.
   // arr's SetOwner() is called, to signal that it is the user's respponsability to
   // delete the histograms, possibly by deleting the arrary.
   //    TObjArray aSlices;
   //    h2->FitSlicesY(func, 0, -1, 0, "QNR", &aSlices);
   // will already delete the histograms once aSlice goes out of scope. aSlices will
   // contain the histogram for the i-th parameter of the fit function at aSlices[i];
   // aSlices[n] (n being the number of parameters) contains the chi2 distribution of
   // the fits.
   //
   // If arr is NULL, the generated histograms are added to the list of objects
   // in the current directory. It is the user's responsability to delete
   // these histograms.
   //
   //  Example: Assume a 2-d histogram h2
   //   Root > h2->FitSlicesY(); produces 4 TH1D histograms
   //          with h2_0 containing parameter 0(Constant) for a Gaus fit
   //                    of each bin in X projected along Y
   //          with h2_1 containing parameter 1(Mean) for a gaus fit
   //          with h2_2 containing parameter 2(RMS)  for a gaus fit
   //          with h2_chi2 containing the chisquare/number of degrees of freedom for a gaus fit
   //
   //   Root > h2->FitSlicesY(0,15,22,10);
   //          same as above, but only for bins 15 to 22 along X
   //          and only for bins in X for which the corresponding projection
   //          along Y has more than cut bins filled.
   //
   //  NOTE: To access the generated histograms in the current directory, do eg:
   //     TH1D *h2_1 = (TH1D*)gDirectory->Get("h2_1");
   //
   // A complete example of this function is given in begin_html <a href="examples/fitslicesy.C.html">tutorial:fitslicesy.C</a> end_html
   // with the following output:
   //Begin_Html
   /*
   <img src="gif/fitslicesy.gif">
   */
   //End_Html

   DoFitSlices(false, f1, firstxbin, lastxbin, cut, option, arr);

}

Int_t TH2::GetBin(Int_t binx, Int_t biny, Int_t) const
{
   // See comments in TH1::GetBin
   Int_t ofy = fYaxis.GetNbins() + 1; // overflow bin
   if (biny < 0) biny = 0;
   if (biny > ofy) biny = ofy;

   return TH1::GetBin(binx) + (fXaxis.GetNbins() + 2) * biny;
}


//______________________________________________________________________________
Double_t TH2::GetBinWithContent2(Double_t c, Int_t &binx, Int_t &biny, Int_t firstxbin, Int_t lastxbin,
                                 Int_t firstybin, Int_t lastybin, Double_t maxdiff) const
{
   // compute first cell (binx,biny) in the range [firstxbin,lastxbin][firstybin,lastybin] for which
   // diff = abs(cell_content-c) <= maxdiff
   // In case several cells in the specified range with diff=0 are found
   // the first cell found is returned in binx,biny.
   // In case several cells in the specified range satisfy diff <=maxdiff
   // the cell with the smallest difference is returned in binx,biny.
   // In all cases the function returns the smallest difference.
   //
   // NOTE1: if firstxbin < 0, firstxbin is set to 1
   //        if (lastxbin < firstxbin then lastxbin is set to the number of bins in X
   //          ie if firstxbin=1 and lastxbin=0 (default) the search is on all bins in X except
   //          for X's under- and overflow bins.
   //        if firstybin < 0, firstybin is set to 1
   //        if (lastybin < firstybin then lastybin is set to the number of bins in Y
   //          ie if firstybin=1 and lastybin=0 (default) the search is on all bins in Y except
   //          for Y's under- and overflow bins.
   // NOTE2: if maxdiff=0 (default), the first cell with content=c is returned.

   if (fDimension != 2) {
      binx = -1;
      biny = -1;
      Error("GetBinWithContent2","function is only valid for 2-D histograms");
      return 0;
   }
   if (firstxbin < 0) firstxbin = 1;
   if (lastxbin < firstxbin) lastxbin = fXaxis.GetNbins();
   if (firstybin < 0) firstybin = 1;
   if (lastybin < firstybin) lastybin = fYaxis.GetNbins();
   Double_t diff, curmax = 1.e240;
   for (Int_t j = firstybin; j <= lastybin; j++) {
      for (Int_t i = firstxbin; i <= lastxbin; i++) {
         diff = TMath::Abs(GetBinContent(i,j)-c);
         if (diff <= 0) {binx = i; biny=j; return diff;}
         if (diff < curmax && diff <= maxdiff) {curmax = diff, binx=i; biny=j;}
      }
   }
   return curmax;
}


//______________________________________________________________________________
Double_t TH2::GetCorrelationFactor(Int_t axis1, Int_t axis2) const
{
   // Return correlation factor between axis1 and axis2.

   if (axis1 < 1 || axis2 < 1 || axis1 > 2 || axis2 > 2) {
      Error("GetCorrelationFactor","Wrong parameters");
      return 0;
   }
   if (axis1 == axis2) return 1;
   Double_t rms1 = GetRMS(axis1);
   if (rms1 == 0) return 0;
   Double_t rms2 = GetRMS(axis2);
   if (rms2 == 0) return 0;
   return GetCovariance(axis1,axis2)/rms1/rms2;
}


//______________________________________________________________________________
Double_t TH2::GetCovariance(Int_t axis1, Int_t axis2) const
{
   // Return covariance between axis1 and axis2.

   if (axis1 < 1 || axis2 < 1 || axis1 > 2 || axis2 > 2) {
      Error("GetCovariance","Wrong parameters");
      return 0;
   }
   Double_t stats[kNstat];
   GetStats(stats);
   Double_t sumw   = stats[0];
   //Double_t sumw2  = stats[1];
   Double_t sumwx  = stats[2];
   Double_t sumwx2 = stats[3];
   Double_t sumwy  = stats[4];
   Double_t sumwy2 = stats[5];
   Double_t sumwxy = stats[6];

   if (sumw == 0) return 0;
   if (axis1 == 1 && axis2 == 1) {
      return TMath::Abs(sumwx2/sumw - sumwx/sumw*sumwx/sumw);
   }
   if (axis1 == 2 && axis2 == 2) {
      return TMath::Abs(sumwy2/sumw - sumwy/sumw*sumwy/sumw);
   }
   return sumwxy/sumw - sumwx/sumw*sumwy/sumw;
}


//______________________________________________________________________________
void TH2::GetRandom2(Double_t &x, Double_t &y)
{
   // Return 2 random numbers along axis x and y distributed according
   // the cellcontents of a 2-dim histogram
   // return a NaN if the histogram has a bin with negative content

   Int_t nbinsx = GetNbinsX();
   Int_t nbinsy = GetNbinsY();
   Int_t nbins  = nbinsx*nbinsy;
   Double_t integral;
   // compute integral checking that all bins have positive content (see ROOT-5894)
   if (fIntegral) {
      if (fIntegral[nbins+1] != fEntries) integral = ComputeIntegral(true);
      else integral = fIntegral[nbins];
   } else {
      integral = ComputeIntegral(true);
   }
   if (integral == 0 ) { x = 0; y = 0; return;}
   // case histogram has negative bins
   if (integral == TMath::QuietNaN() ) { x = TMath::QuietNaN(); y = TMath::QuietNaN(); return;}

   Double_t r1 = gRandom->Rndm();
   Int_t ibin = TMath::BinarySearch(nbins,fIntegral,(Double_t) r1);
   Int_t biny = ibin/nbinsx;
   Int_t binx = ibin - nbinsx*biny;
   x = fXaxis.GetBinLowEdge(binx+1);
   if (r1 > fIntegral[ibin]) x +=
      fXaxis.GetBinWidth(binx+1)*(r1-fIntegral[ibin])/(fIntegral[ibin+1] - fIntegral[ibin]);
   y = fYaxis.GetBinLowEdge(biny+1) + fYaxis.GetBinWidth(biny+1)*gRandom->Rndm();
}


//______________________________________________________________________________
void TH2::GetStats(Double_t *stats) const
{
   // Fill the array stats from the contents of this histogram
   // The array stats must be correctly dimensionned in the calling program.
   // stats[0] = sumw
   // stats[1] = sumw2
   // stats[2] = sumwx
   // stats[3] = sumwx2
   // stats[4] = sumwy
   // stats[5] = sumwy2
   // stats[6] = sumwxy
   //
   // If no axis-subranges are specified (via TAxis::SetRange), the array stats
   // is simply a copy of the statistics quantities computed at filling time.
   // If sub-ranges are specified, the function recomputes these quantities
   // from the bin contents in the current axis ranges.
   //
   //  Note that the mean value/RMS is computed using the bins in the currently
   //  defined ranges (see TAxis::SetRange). By default the ranges include
   //  all bins from 1 to nbins included, excluding underflows and overflows.
   //  To force the underflows and overflows in the computation, one must
   //  call the static function TH1::StatOverflows(kTRUE) before filling
   //  the histogram.

   if (fBuffer) ((TH2*)this)->BufferEmpty();

   if ((fTsumw == 0 && fEntries > 0) || fXaxis.TestBit(TAxis::kAxisRange) || fYaxis.TestBit(TAxis::kAxisRange)) {
      std::fill(stats, stats + 7, 0);

      Int_t firstBinX = fXaxis.GetFirst();
      Int_t lastBinX  = fXaxis.GetLast();
      Int_t firstBinY = fYaxis.GetFirst();
      Int_t lastBinY  = fYaxis.GetLast();
      // include underflow/overflow if TH1::StatOverflows(kTRUE) in case no range is set on the axis
      if (fgStatOverflows) {
        if ( !fXaxis.TestBit(TAxis::kAxisRange) ) {
            if (firstBinX == 1) firstBinX = 0;
            if (lastBinX ==  fXaxis.GetNbins() ) lastBinX += 1;
         }
         if ( !fYaxis.TestBit(TAxis::kAxisRange) ) {
            if (firstBinY == 1) firstBinY = 0;
            if (lastBinY ==  fYaxis.GetNbins() ) lastBinY += 1;
         }
      }
      for (Int_t biny = firstBinY; biny <= lastBinY; ++biny) {
         Double_t y = fYaxis.GetBinCenter(biny);
         for (Int_t binx = firstBinX; binx <= lastBinX; ++binx) {
            Double_t x = fXaxis.GetBinCenter(binx);
            //w   = TMath::Abs(GetBinContent(bin));
            Int_t bin = GetBin(binx,biny);
            Double_t w = RetrieveBinContent(bin);
            Double_t wx = w * x; // avoid some extra multiplications at the expense of some clarity
            Double_t wy = w * y;

            stats[0] += w;
            stats[1] += GetBinErrorSqUnchecked(bin);
            stats[2] += wx;
            stats[3] += wx * x;
            stats[4] += wy;
            stats[5] += wy * y;
            stats[6] += wx * y;
         }
      }
   } else {
      stats[0] = fTsumw;
      stats[1] = fTsumw2;
      stats[2] = fTsumwx;
      stats[3] = fTsumwx2;
      stats[4] = fTsumwy;
      stats[5] = fTsumwy2;
      stats[6] = fTsumwxy;
   }
}


//______________________________________________________________________________
Double_t TH2::Integral(Option_t *option) const
{
   // Return integral of bin contents. Only bins in the bins range are considered.
   // By default the integral is computed as the sum of bin contents in the range.
   // if option "width" is specified, the integral is the sum of
   // the bin contents multiplied by the bin width in x and in y.

   return Integral(fXaxis.GetFirst(),fXaxis.GetLast(),
      fYaxis.GetFirst(),fYaxis.GetLast(),option);
}


//______________________________________________________________________________
Double_t TH2::Integral(Int_t firstxbin, Int_t lastxbin, Int_t firstybin, Int_t lastybin, Option_t *option) const
{
   // Return integral of bin contents in range [firstxbin,lastxbin],[firstybin,lastybin]
   // for a 2-D histogram
   // By default the integral is computed as the sum of bin contents in the range.
   // if option "width" is specified, the integral is the sum of
   // the bin contents multiplied by the bin width in x and in y.
   double err = 0;
   return DoIntegral(firstxbin,lastxbin,firstybin,lastybin,-1,0,err,option);
}


//______________________________________________________________________________
Double_t TH2::IntegralAndError(Int_t firstxbin, Int_t lastxbin, Int_t firstybin, Int_t lastybin, Double_t & error, Option_t *option) const
{
   // Return integral of bin contents in range [firstxbin,lastxbin],[firstybin,lastybin]
   // for a 2-D histogram. Calculates also the integral error using error propagation
   // from the bin errors assumming that all the bins are uncorrelated.
   // By default the integral is computed as the sum of bin contents in the range.
   // if option "width" is specified, the integral is the sum of
   // the bin contents multiplied by the bin width in x and in y.
   return DoIntegral(firstxbin,lastxbin,firstybin,lastybin,-1,0,error,option,kTRUE);
}


//______________________________________________________________________________
Double_t TH2::Interpolate(Double_t)
{
   //illegal for a TH2

   Error("Interpolate","This function must be called with 2 arguments for a TH2");
   return 0;
}


//______________________________________________________________________________
 Double_t TH2::Interpolate(Double_t x, Double_t y)
{
   // Given a point P(x,y), Interpolate approximates the value via bilinear
   // interpolation based on the four nearest bin centers
   // see Wikipedia, Bilinear Interpolation
   // Andy Mastbaum 10/8/2008
   // vaguely based on R.Raja 6-Sep-2008

   Double_t f=0;
   Double_t x1=0,x2=0,y1=0,y2=0;
   Double_t dx,dy;
   Int_t bin_x = fXaxis.FindBin(x);
   Int_t bin_y = fYaxis.FindBin(y);
   if(bin_x<1 || bin_x>GetNbinsX() || bin_y<1 || bin_y>GetNbinsY()) {
      Error("Interpolate","Cannot interpolate outside histogram domain.");
      return 0;
   }
   Int_t quadrant = 0; // CCW from UR 1,2,3,4
   // which quadrant of the bin (bin_P) are we in?
   dx = fXaxis.GetBinUpEdge(bin_x)-x;
   dy = fYaxis.GetBinUpEdge(bin_y)-y;
   if (dx<=fXaxis.GetBinWidth(bin_x)/2 && dy<=fYaxis.GetBinWidth(bin_y)/2)
   quadrant = 1; // upper right
   if (dx>fXaxis.GetBinWidth(bin_x)/2 && dy<=fYaxis.GetBinWidth(bin_y)/2)
   quadrant = 2; // upper left
   if (dx>fXaxis.GetBinWidth(bin_x)/2 && dy>fYaxis.GetBinWidth(bin_y)/2)
   quadrant = 3; // lower left
   if (dx<=fXaxis.GetBinWidth(bin_x)/2 && dy>fYaxis.GetBinWidth(bin_y)/2)
   quadrant = 4; // lower right
   switch(quadrant) {
   case 1:
      x1 = fXaxis.GetBinCenter(bin_x);
      y1 = fYaxis.GetBinCenter(bin_y);
      x2 = fXaxis.GetBinCenter(bin_x+1);
      y2 = fYaxis.GetBinCenter(bin_y+1);
      break;
   case 2:
      x1 = fXaxis.GetBinCenter(bin_x-1);
      y1 = fYaxis.GetBinCenter(bin_y);
      x2 = fXaxis.GetBinCenter(bin_x);
      y2 = fYaxis.GetBinCenter(bin_y+1);
      break;
   case 3:
      x1 = fXaxis.GetBinCenter(bin_x-1);
      y1 = fYaxis.GetBinCenter(bin_y-1);
      x2 = fXaxis.GetBinCenter(bin_x);
      y2 = fYaxis.GetBinCenter(bin_y);
      break;
   case 4:
      x1 = fXaxis.GetBinCenter(bin_x);
      y1 = fYaxis.GetBinCenter(bin_y-1);
      x2 = fXaxis.GetBinCenter(bin_x+1);
      y2 = fYaxis.GetBinCenter(bin_y);
      break;
   }
   Int_t bin_x1 = fXaxis.FindBin(x1);
   if(bin_x1<1) bin_x1=1;
   Int_t bin_x2 = fXaxis.FindBin(x2);
   if(bin_x2>GetNbinsX()) bin_x2=GetNbinsX();
   Int_t bin_y1 = fYaxis.FindBin(y1);
   if(bin_y1<1) bin_y1=1;
   Int_t bin_y2 = fYaxis.FindBin(y2);
   if(bin_y2>GetNbinsY()) bin_y2=GetNbinsY();
   Int_t bin_q22 = GetBin(bin_x2,bin_y2);
   Int_t bin_q12 = GetBin(bin_x1,bin_y2);
   Int_t bin_q11 = GetBin(bin_x1,bin_y1);
   Int_t bin_q21 = GetBin(bin_x2,bin_y1);
   Double_t q11 = RetrieveBinContent(bin_q11);
   Double_t q12 = RetrieveBinContent(bin_q12);
   Double_t q21 = RetrieveBinContent(bin_q21);
   Double_t q22 = RetrieveBinContent(bin_q22);
   Double_t d = 1.0*(x2-x1)*(y2-y1);
   f = 1.0*q11/d*(x2-x)*(y2-y)+1.0*q21/d*(x-x1)*(y2-y)+1.0*q12/d*(x2-x)*(y-y1)+1.0*q22/d*(x-x1)*(y-y1);
   return f;
}


//______________________________________________________________________________
Double_t TH2::Interpolate(Double_t, Double_t, Double_t)
{
   //illegal for a TH2

   Error("Interpolate","This function must be called with 2 arguments for a TH2");
   return 0;
}


//______________________________________________________________________________
Double_t TH2::KolmogorovTest(const TH1 *h2, Option_t *option) const
{
   // Statistical test of compatibility in shape between
   // THIS histogram and h2, using Kolmogorov test.
   //     Default: Ignore under- and overflow bins in comparison
   //
   //     option is a character string to specify options
   //         "U" include Underflows in test
   //         "O" include Overflows
   //         "N" include comparison of normalizations
   //         "D" Put out a line of "Debug" printout
   //         "M" Return the Maximum Kolmogorov distance instead of prob
   //
   //   The returned function value is the probability of test
   //       (much less than one means NOT compatible)
   //
   //   The KS test uses the distance between the pseudo-CDF's obtained
   //   from the histogram. Since in 2D the order for generating the pseudo-CDF is
   //   arbitrary, two pairs of pseudo-CDF are used, one starting from the x axis the
   //   other from the y axis and the maximum distance is the average of the two maximum
   //   distances obtained.
   //
   //  Code adapted by Rene Brun from original HBOOK routine HDIFF

   TString opt = option;
   opt.ToUpper();

   Double_t prb = 0;
   TH1 *h1 = (TH1*)this;
   if (h2 == 0) return 0;
   const TAxis *xaxis1 = h1->GetXaxis();
   const TAxis *xaxis2 = h2->GetXaxis();
   const TAxis *yaxis1 = h1->GetYaxis();
   const TAxis *yaxis2 = h2->GetYaxis();
   Int_t ncx1   = xaxis1->GetNbins();
   Int_t ncx2   = xaxis2->GetNbins();
   Int_t ncy1   = yaxis1->GetNbins();
   Int_t ncy2   = yaxis2->GetNbins();

   // Check consistency of dimensions
   if (h1->GetDimension() != 2 || h2->GetDimension() != 2) {
      Error("KolmogorovTest","Histograms must be 2-D\n");
      return 0;
   }

   // Check consistency in number of channels
   if (ncx1 != ncx2) {
      Error("KolmogorovTest","Number of channels in X is different, %d and %d\n",ncx1,ncx2);
      return 0;
   }
   if (ncy1 != ncy2) {
      Error("KolmogorovTest","Number of channels in Y is different, %d and %d\n",ncy1,ncy2);
      return 0;
   }

   // Check consistency in channel edges
   Bool_t afunc1 = kFALSE;
   Bool_t afunc2 = kFALSE;
   Double_t difprec = 1e-5;
   Double_t diff1 = TMath::Abs(xaxis1->GetXmin() - xaxis2->GetXmin());
   Double_t diff2 = TMath::Abs(xaxis1->GetXmax() - xaxis2->GetXmax());
   if (diff1 > difprec || diff2 > difprec) {
      Error("KolmogorovTest","histograms with different binning along X");
      return 0;
   }
   diff1 = TMath::Abs(yaxis1->GetXmin() - yaxis2->GetXmin());
   diff2 = TMath::Abs(yaxis1->GetXmax() - yaxis2->GetXmax());
   if (diff1 > difprec || diff2 > difprec) {
      Error("KolmogorovTest","histograms with different binning along Y");
      return 0;
   }

   //   Should we include Uflows, Oflows?
   Int_t ibeg = 1, jbeg = 1;
   Int_t iend = ncx1, jend = ncy1;
   if (opt.Contains("U")) {ibeg = 0; jbeg = 0;}
   if (opt.Contains("O")) {iend = ncx1+1; jend = ncy1+1;}

   Int_t i,j;
   Double_t sum1  = 0;
   Double_t sum2  = 0;
   Double_t w1    = 0;
   Double_t w2    = 0;
   for (i = ibeg; i <= iend; i++) {
      for (j = jbeg; j <= jend; j++) {
         sum1 += h1->GetBinContent(i,j);
         sum2 += h2->GetBinContent(i,j);
         Double_t ew1   = h1->GetBinError(i,j);
         Double_t ew2   = h2->GetBinError(i,j);
         w1   += ew1*ew1;
         w2   += ew2*ew2;

      }
   }

   //    Check that both scatterplots contain events
   if (sum1 == 0) {
      Error("KolmogorovTest","Integral is zero for h1=%s\n",h1->GetName());
      return 0;
   }
   if (sum2 == 0) {
      Error("KolmogorovTest","Integral is zero for h2=%s\n",h2->GetName());
      return 0;
   }
   // calculate the effective entries.
   // the case when errors are zero (w1 == 0 or w2 ==0) are equivalent to
   // compare to a function. In that case the rescaling is done only on sqrt(esum2) or sqrt(esum1)
   Double_t esum1 = 0, esum2 = 0;
   if (w1 > 0)
      esum1 = sum1 * sum1 / w1;
   else
      afunc1 = kTRUE;    // use later for calculating z

   if (w2 > 0)
      esum2 = sum2 * sum2 / w2;
   else
      afunc2 = kTRUE;    // use later for calculating z

   if (afunc2 && afunc1) {
      Error("KolmogorovTest","Errors are zero for both histograms\n");
      return 0;
   }

   //   Find first Kolmogorov distance
   Double_t s1 = 1/sum1;
   Double_t s2 = 1/sum2;
   Double_t dfmax1 = 0;
   Double_t rsum1=0, rsum2=0;
   for (i=ibeg;i<=iend;i++) {
      for (j=jbeg;j<=jend;j++) {
         rsum1 += s1*h1->GetBinContent(i,j);
         rsum2 += s2*h2->GetBinContent(i,j);
         dfmax1  = TMath::Max(dfmax1, TMath::Abs(rsum1-rsum2));
      }
   }

   //   Find second Kolmogorov distance
   Double_t dfmax2 = 0;
   rsum1=0, rsum2=0;
   for (j=jbeg;j<=jend;j++) {
      for (i=ibeg;i<=iend;i++) {
         rsum1 += s1*h1->GetBinContent(i,j);
         rsum2 += s2*h2->GetBinContent(i,j);
         dfmax2 = TMath::Max(dfmax2, TMath::Abs(rsum1-rsum2));
      }
   }

   //    Get Kolmogorov probability: use effective entries, esum1 or esum2,  for normalizing it
   Double_t factnm;
   if (afunc1)      factnm = TMath::Sqrt(esum2);
   else if (afunc2) factnm = TMath::Sqrt(esum1);
   else             factnm = TMath::Sqrt(esum1*sum2/(esum1+esum2));

   // take average of the two distances
   Double_t dfmax = 0.5*(dfmax1+dfmax2);
   Double_t z  = dfmax*factnm;

   prb = TMath::KolmogorovProb(z);

   Double_t prb1 = 0, prb2 = 0;
   // option N to combine normalization makes sense if both afunc1 and afunc2 are false
   if (opt.Contains("N")  && !(afunc1 || afunc2 ) ) {
      // Combine probabilities for shape and normalization
      prb1   = prb;
      Double_t d12    = esum1-esum2;
      Double_t chi2   = d12*d12/(esum1+esum2);
      prb2   = TMath::Prob(chi2,1);
      //     see Eadie et al., section 11.6.2
      if (prb > 0 && prb2 > 0) prb = prb*prb2*(1-TMath::Log(prb*prb2));
      else                     prb = 0;
   }

   //    debug printout
   if (opt.Contains("D")) {
      printf(" Kolmo Prob  h1 = %s, sum1=%g\n",h1->GetName(),sum1);
      printf(" Kolmo Prob  h2 = %s, sum2=%g\n",h2->GetName(),sum2);
      printf(" Kolmo Probabil = %f, Max Dist = %g\n",prb,dfmax);
      if (opt.Contains("N"))
         printf(" Kolmo Probabil = %f for shape alone, =%f for normalisation alone\n",prb1,prb2);
   }
   // This numerical error condition should never occur:
   if (TMath::Abs(rsum1-1) > 0.002) Warning("KolmogorovTest","Numerical problems with h1=%s\n",h1->GetName());
   if (TMath::Abs(rsum2-1) > 0.002) Warning("KolmogorovTest","Numerical problems with h2=%s\n",h2->GetName());

   if(opt.Contains("M"))      return dfmax;  // return avergae of max distance

   return prb;
}


//______________________________________________________________________________
Long64_t TH2::Merge(TCollection *list)
{
   // Add all histograms in the collection to this histogram.
   // This function computes the min/max for the axes,
   // compute a new number of bins, if necessary,
   // add bin contents, errors and statistics.
   // If overflows are present and limits are different the function will fail.
   // The function returns the total number of entries in the result histogram
   // if the merge is successfull, -1 otherwise.
   //
   // IMPORTANT remark. The 2 axis x and y may have different number
   // of bins and different limits, BUT the largest bin width must be
   // a multiple of the smallest bin width and the upper limit must also
   // be a multiple of the bin width.

   if (!list) return 0;
   if (list->IsEmpty()) return (Long64_t) GetEntries();

   TList inlist;
   inlist.AddAll(list);

   TAxis newXAxis;
   TAxis newYAxis;
   Bool_t initialLimitsFound = kFALSE;
   Bool_t allSameLimits = kTRUE;
   Bool_t sameLimitsX = kTRUE;
   Bool_t sameLimitsY = kTRUE;
   Bool_t allHaveLimits = kTRUE;
   Bool_t firstHistWithLimits = kTRUE;

   TIter next(&inlist);
   TH2 * h = this;
   do  {

      Bool_t hasLimits = h->GetXaxis()->GetXmin() < h->GetXaxis()->GetXmax();
      allHaveLimits = allHaveLimits && hasLimits;

      if (hasLimits) {
         h->BufferEmpty();

         // this is done in case the first histograms are empty and
         // the histogram have different limits
         if (firstHistWithLimits ) {
            // set axis limits in the case the first histogram did not have limits
            if (h != this ) {
              if (!SameLimitsAndNBins(fXaxis, *(h->GetXaxis())) ) {
                if (h->GetXaxis()->GetXbins()->GetSize() != 0) fXaxis.Set(h->GetXaxis()->GetNbins(), h->GetXaxis()->GetXbins()->GetArray());
                else                                           fXaxis.Set(h->GetXaxis()->GetNbins(), h->GetXaxis()->GetXmin(), h->GetXaxis()->GetXmax());
              }
              if (!SameLimitsAndNBins(fYaxis, *(h->GetYaxis())) ) {
                if (h->GetYaxis()->GetXbins()->GetSize() != 0) fYaxis.Set(h->GetYaxis()->GetNbins(), h->GetYaxis()->GetXbins()->GetArray());
                else                                           fYaxis.Set(h->GetYaxis()->GetNbins(), h->GetYaxis()->GetXmin(), h->GetYaxis()->GetXmax());
              }
            }
            firstHistWithLimits = kFALSE;
         }

         if (!initialLimitsFound) {
            // this is executed the first time an histogram with limits is found
            // to set some initial values on the new axes
            initialLimitsFound = kTRUE;
            if (h->GetXaxis()->GetXbins()->GetSize() != 0) newXAxis.Set(h->GetXaxis()->GetNbins(), h->GetXaxis()->GetXbins()->GetArray());
            else                                           newXAxis.Set(h->GetXaxis()->GetNbins(), h->GetXaxis()->GetXmin(), h->GetXaxis()->GetXmax());
            if (h->GetYaxis()->GetXbins()->GetSize() != 0) newYAxis.Set(h->GetYaxis()->GetNbins(), h->GetYaxis()->GetXbins()->GetArray());
            else                                           newYAxis.Set(h->GetYaxis()->GetNbins(), h->GetYaxis()->GetXmin(), h->GetYaxis()->GetXmax());
         }
         else {
           // check first if histograms have same bins in X
           if (!SameLimitsAndNBins(newXAxis, *(h->GetXaxis()))) {
             sameLimitsX = kFALSE;
             // recompute in this case the optimal limits
             // The condition to works is that the histogram have same bin with
             // and one common bin edge
             if (!RecomputeAxisLimits(newXAxis, *(h->GetXaxis()))) {
               Error("Merge", "Cannot merge histograms - limits are inconsistent:\n "
                     "first: (%d, %f, %f), second: (%d, %f, %f)",
                     newXAxis.GetNbins(), newXAxis.GetXmin(), newXAxis.GetXmax(),
                     h->GetXaxis()->GetNbins(), h->GetXaxis()->GetXmin(),
                     h->GetXaxis()->GetXmax());
               return -1;
             }
           }

           // check first if histograms have same bins in Y
           if (!SameLimitsAndNBins(newYAxis, *(h->GetYaxis()))) {
             sameLimitsY = kFALSE;
             // recompute in this case the optimal limits
             // The condition to works is that the histogram have same bin with
             // and one common bin edge
             if (!RecomputeAxisLimits(newYAxis, *(h->GetYaxis()))) {
               Error("Merge", "Cannot merge histograms - limits are inconsistent:\n "
                     "first: (%d, %f, %f), second: (%d, %f, %f)",
                     newYAxis.GetNbins(), newYAxis.GetXmin(), newYAxis.GetXmax(),
                     h->GetYaxis()->GetNbins(), h->GetYaxis()->GetXmin(),
                     h->GetYaxis()->GetXmax());
               return -1;
             }
           }
           allSameLimits = sameLimitsY && sameLimitsX;
         }
      }
   }  while ( ( h = dynamic_cast<TH2*> ( next() ) ) != NULL );
   if (!h && (*next) ) {
      Error("Merge","Attempt to merge object of class: %s to a %s",
            (*next)->ClassName(),this->ClassName());
      return -1;
   }
   next.Reset();

   // In the case of histogram with different limits
   // newX(Y)Axis will now have the new found limits
   // but one needs first to clone this histogram to perform the merge
   // The clone is not needed when all histograms have the same limits
   TH2 * hclone = 0;
   if (!allSameLimits) {
      // We don't want to add the clone to gDirectory,
      // so remove our kMustCleanup bit temporarily
      Bool_t mustCleanup = TestBit(kMustCleanup);
      if (mustCleanup) ResetBit(kMustCleanup);
      hclone = (TH2*)IsA()->New();
      hclone->SetDirectory(0);
      Copy(*hclone);
      if (mustCleanup) SetBit(kMustCleanup);
      BufferEmpty(1);         // To remove buffer.
      Reset();                // BufferEmpty sets limits so we can't use it later.
      SetEntries(0);
      inlist.AddFirst(hclone);
   }

   if (!allSameLimits && initialLimitsFound) {
     if (!sameLimitsX) {
       fXaxis.SetRange(0,0);
       if (newXAxis.GetXbins()->GetSize() != 0) fXaxis.Set(newXAxis.GetNbins(),newXAxis.GetXbins()->GetArray());
       else                                     fXaxis.Set(newXAxis.GetNbins(),newXAxis.GetXmin(), newXAxis.GetXmax());
     }
     if (!sameLimitsY) {
       fYaxis.SetRange(0,0);
       if (newYAxis.GetXbins()->GetSize() != 0) fYaxis.Set(newYAxis.GetNbins(),newYAxis.GetXbins()->GetArray());
       else                                     fYaxis.Set(newYAxis.GetNbins(),newYAxis.GetXmin(), newYAxis.GetXmax());
     }
     fZaxis.Set(1,0,1);
     fNcells = (fXaxis.GetNbins()+2)*(fYaxis.GetNbins()+2);
     SetBinsLength(fNcells);
     if (fSumw2.fN) {
       fSumw2.Set(fNcells);
     }
   }

   if (!allHaveLimits) {
      // fill this histogram with all the data from buffers of histograms without limits
      while ( (h = dynamic_cast<TH2*> (next())) ) {
         if (h->GetXaxis()->GetXmin() >= h->GetXaxis()->GetXmax() && h->fBuffer) {
            // no limits
            Int_t nbentries = (Int_t)h->fBuffer[0];
            for (Int_t i = 0; i < nbentries; i++)
               Fill(h->fBuffer[3*i + 2], h->fBuffer[3*i + 3], h->fBuffer[3*i + 1]);
            // Entries from buffers have to be filled one by one
            // because FillN doesn't resize histograms.
         }
      }
      if (!initialLimitsFound) {
         if (hclone) {
            inlist.Remove(hclone);
            delete hclone;
         }
         return (Long64_t) GetEntries();  // all histograms have been processed
      }
      next.Reset();
   }

   //merge bin contents and errors
   Double_t stats[kNstat], totstats[kNstat];
   for (Int_t i=0;i<kNstat;i++) {totstats[i] = stats[i] = 0;}
   GetStats(totstats);
   Double_t nentries = GetEntries();
   Int_t binx, biny, ix, iy, nx, ny, bin, ibin;
   Double_t cu;
   Int_t nbix = fXaxis.GetNbins();
   Bool_t canExtend = CanExtendAllAxes();
   SetCanExtend(TH1::kNoAxis); // reset, otherwise setting the under/overflow will extend the axis

   while ((h=(TH2*)next())) {

      // skip empty histograms
      Double_t histEntries = h->GetEntries();
      if (h->fTsumw == 0 && histEntries == 0) continue;

      // process only if the histogram has limits; otherwise it was processed before
      if (h->GetXaxis()->GetXmin() < h->GetXaxis()->GetXmax()) {
         // import statistics
         h->GetStats(stats);
         for (Int_t i = 0; i < kNstat; i++)
            totstats[i] += stats[i];
         nentries += histEntries;

         nx = h->GetXaxis()->GetNbins();
         ny = h->GetYaxis()->GetNbins();

         for (biny = 0; biny <= ny + 1; biny++) {
            if (!allSameLimits)
               iy = fYaxis.FindBin(h->GetYaxis()->GetBinCenter(biny));
            else
               iy = biny;
            for (binx = 0; binx <= nx + 1; binx++) {
               bin = binx +(nx+2)*biny;

               cu = h->RetrieveBinContent(bin);
               if (!allSameLimits) {
                  if (cu != 0 && ( (!sameLimitsX && (binx == 0 || binx == nx+1)) || (!sameLimitsY && (biny == 0 || biny == ny+1)) )) {
                     Error("Merge", "Cannot merge histograms - the histograms have"
                           " different limits and undeflows/overflows are present."
                           " The initial histogram is now broken!");
                     return -1;
                  }
                  ix = fXaxis.FindBin(h->GetXaxis()->GetBinCenter(binx));
               }
               else {
                  // case histograms with the same limits
                  ix = binx;
               }
               ibin = ix +(nbix+2)*iy;

               if (ibin < 0) continue;
               AddBinContent(ibin,cu);
               if (fSumw2.fN) {
                  Double_t error1 = h->GetBinError(bin);
                  fSumw2.fArray[ibin] += error1*error1;
               }
            }
         }
      }
   }
   SetCanExtend(canExtend);

   //copy merged stats
   PutStats(totstats);
   SetEntries(nentries);
   if (hclone) {
      inlist.Remove(hclone);
      delete hclone;
   }
   return (Long64_t)nentries;
}


//______________________________________________________________________________
TH2 *TH2::RebinX(Int_t ngroup, const char *newname)
{
   // Rebin only the X axis
   // see Rebin2D

   return Rebin2D(ngroup, 1, newname);
}


//______________________________________________________________________________
TH2 *TH2::RebinY(Int_t ngroup, const char *newname)
{
   // Rebin only the Y axis
   // see Rebin2D

   return Rebin2D(1, ngroup, newname);
}


//______________________________________________________________________________
TH2 *TH2::Rebin2D(Int_t nxgroup, Int_t nygroup, const char *newname)
{
   // Rebin this histogram grouping nxgroup/nygroup bins along the xaxis/yaxis together.
   //
   //   if newname is not blank a new temporary histogram hnew is created.
   //   else the current histogram is modified (default)
   //   The parameter nxgroup/nygroup indicate how many bins along the xaxis/yaxis of this
   //   have to me merged into one bin of hnew
   //   If the original histogram has errors stored (via Sumw2), the resulting
   //   histograms has new errors correctly calculated.
   //
   //   examples: if hpxpy is an existing TH2 histogram with 40 x 40 bins
   //     hpxpy->Rebin2D();  // merges two bins along the xaxis and yaxis in one in hpxpy
   //                        // Carefull: previous contents of hpxpy are lost
   //     hpxpy->RebinX(5);  //merges five bins along the xaxis in one in hpxpy
   //     TH2 *hnew = hpxpy->RebinY(5,"hnew"); // creates a new histogram hnew
   //                                          // merging 5 bins of h1 along the yaxis in one bin
   //
   //   NOTE : If nxgroup/nygroup is not an exact divider of the number of bins,
   //          along the xaxis/yaxis the top limit(s) of the rebinned histogram
   //          is changed to the upper edge of the xbin=newxbins*nxgroup resp.
   //          ybin=newybins*nygroup and the corresponding bins are added to
   //          the overflow bin.
   //          Statistics will be recomputed from the new bin contents.

   Int_t nxbins  = fXaxis.GetNbins();
   Int_t nybins  = fYaxis.GetNbins();
   Int_t nx      = nxbins + 2; // normal bins + underflow and overflow
   Int_t ny      = nybins + 2;
   Double_t xmin  = fXaxis.GetXmin();
   Double_t xmax  = fXaxis.GetXmax();
   Double_t ymin  = fYaxis.GetXmin();
   Double_t ymax  = fYaxis.GetXmax();

   if (GetDimension() != 2) {
      Error("Rebin2D", "Histogram must be TH2. This histogram has %d dimensions.", GetDimension());
      return 0;
   }
   if ((nxgroup <= 0) || (nxgroup > nxbins)) {
      Error("Rebin2D", "Illegal value of nxgroup=%d",nxgroup);
      return 0;
   }
   if ((nygroup <= 0) || (nygroup > nybins)) {
      Error("Rebin2D", "Illegal value of nygroup=%d",nygroup);
      return 0;
   }

   Int_t newxbins = nxbins / nxgroup;
   Int_t newybins = nybins / nygroup;
   Int_t newnx = newxbins + 2; // regular bins + overflow / underflow
   Int_t newny = newybins + 2; // regular bins + overflow / underflow

   // Save old bin contents into a new array
   Double_t *oldBins = new Double_t[fNcells];
   for (Int_t i = 0; i < fNcells; ++i) oldBins[i] = RetrieveBinContent(i);

   Double_t* oldErrors = NULL;
   if (fSumw2.fN) {
      oldErrors = new Double_t[fNcells];
      for (Int_t i = 0; i < fNcells; ++i) oldErrors[i] = GetBinErrorSqUnchecked(i);
   }

   // create a clone of the old histogram if newname is specified
   TH2* hnew = this;
   if (newname && strlen(newname)) {
      hnew = (TH2*)Clone();
      hnew->SetName(newname);
   }

   bool resetStat = false;

   // change axis specs and rebuild bin contents array
   if(newxbins * nxgroup != nxbins) {
      xmax = fXaxis.GetBinUpEdge(newxbins * nxgroup);
      resetStat = true; // stats must be reset because top bins will be moved to overflow bin
   }
   if(newybins * nygroup != nybins) {
      ymax = fYaxis.GetBinUpEdge(newybins * nygroup);
      resetStat = true; // stats must be reset because top bins will be moved to overflow bin
   }

   // save the TAttAxis members (reset by SetBins) for x axis
   Int_t    nXdivisions  = fXaxis.GetNdivisions();
   Color_t  xAxisColor   = fXaxis.GetAxisColor();
   Color_t  xLabelColor  = fXaxis.GetLabelColor();
   Style_t  xLabelFont   = fXaxis.GetLabelFont();
   Float_t  xLabelOffset = fXaxis.GetLabelOffset();
   Float_t  xLabelSize   = fXaxis.GetLabelSize();
   Float_t  xTickLength  = fXaxis.GetTickLength();
   Float_t  xTitleOffset = fXaxis.GetTitleOffset();
   Float_t  xTitleSize   = fXaxis.GetTitleSize();
   Color_t  xTitleColor  = fXaxis.GetTitleColor();
   Style_t  xTitleFont   = fXaxis.GetTitleFont();
   // save the TAttAxis members (reset by SetBins) for y axis
   Int_t    nYdivisions  = fYaxis.GetNdivisions();
   Color_t  yAxisColor   = fYaxis.GetAxisColor();
   Color_t  yLabelColor  = fYaxis.GetLabelColor();
   Style_t  yLabelFont   = fYaxis.GetLabelFont();
   Float_t  yLabelOffset = fYaxis.GetLabelOffset();
   Float_t  yLabelSize   = fYaxis.GetLabelSize();
   Float_t  yTickLength  = fYaxis.GetTickLength();
   Float_t  yTitleOffset = fYaxis.GetTitleOffset();
   Float_t  yTitleSize   = fYaxis.GetTitleSize();
   Color_t  yTitleColor  = fYaxis.GetTitleColor();
   Style_t  yTitleFont   = fYaxis.GetTitleFont();


   // copy merged bin contents (ignore under/overflows)
   if (nxgroup != 1 || nygroup != 1) {
      if(fXaxis.GetXbins()->GetSize() > 0 || fYaxis.GetXbins()->GetSize() > 0){
         // variable bin sizes in x or y, don't treat both cases separately
         Double_t *xbins = new Double_t[newxbins + 1];
         for(Int_t i = 0; i <= newxbins; ++i) xbins[i] = fXaxis.GetBinLowEdge(1 + i * nxgroup);
         Double_t *ybins = new Double_t[newybins + 1];
         for(Int_t i = 0; i <= newybins; ++i) ybins[i] = fYaxis.GetBinLowEdge(1 + i * nygroup);
         hnew->SetBins(newxbins, xbins, newybins, ybins); // changes also errors array (if any)
         delete [] xbins;
         delete [] ybins;
      } else {
         hnew->SetBins(newxbins, xmin, xmax, newybins, ymin, ymax); //changes also errors array
      }

      // (0, 0): x - underflow; y - underflow
      hnew->UpdateBinContent(0, oldBins[0]);
      if (oldErrors) hnew->fSumw2[0] = 0;

      // (x, 0): x - regular / overflow; y - underflow
      for(Int_t binx = 1, oldbinx = 1; binx < newnx; ++binx, oldbinx += nxgroup){
         Double_t binContent = 0.0, binErrorSq = 0.0;
         for (Int_t i = 0; i < nxgroup && (oldbinx + i) < nx; ++i) {
            Int_t bin = oldbinx + i;
            binContent += oldBins[bin];
            if(oldErrors) binErrorSq += oldErrors[bin];
         }
         Int_t newbin = binx;
         hnew->UpdateBinContent(newbin, binContent);
         if (oldErrors) hnew->fSumw2[newbin] = binErrorSq;
      }

      // (0, y): x - underflow; y - regular / overflow
      for(Int_t biny = 1, oldbiny = 1; biny < newny; ++biny, oldbiny += nygroup){
         Double_t binContent = 0.0, binErrorSq = 0.0;
         for (Int_t j = 0; j < nygroup && (oldbiny + j) < ny; ++j) {
            Int_t bin = (oldbiny + j) * nx;
            binContent += oldBins[bin];
            if(oldErrors) binErrorSq += oldErrors[bin];
         }
         Int_t newbin = biny * newnx;
         hnew->UpdateBinContent(newbin, binContent);
         if (oldErrors) hnew->fSumw2[newbin] = binErrorSq;
      }

      // (x, y): x - regular / overflow; y - regular / overflow
      for (Int_t binx = 1, oldbinx = 1; binx < newnx; ++binx, oldbinx += nxgroup) {
         for (Int_t biny = 1, oldbiny = 1; biny < newny; ++biny, oldbiny += nygroup) {
            Double_t binContent = 0.0, binErrorSq = 0.0;
            for (Int_t i = 0; i < nxgroup && (oldbinx + i) < nx; ++i) {
               for (Int_t j = 0; j < nygroup && (oldbiny + j) < ny; ++j) {
                  Int_t bin = oldbinx + i + (oldbiny + j) * nx;
                  binContent += oldBins[bin];
                  if (oldErrors) binErrorSq += oldErrors[bin];
               }
            }
            Int_t newbin = binx + biny * newnx;
            hnew->UpdateBinContent(newbin, binContent);
            if (oldErrors) hnew->fSumw2[newbin] = binErrorSq;
         }
      }
   }

   // Restore x axis attributes
   fXaxis.SetNdivisions(nXdivisions);
   fXaxis.SetAxisColor(xAxisColor);
   fXaxis.SetLabelColor(xLabelColor);
   fXaxis.SetLabelFont(xLabelFont);
   fXaxis.SetLabelOffset(xLabelOffset);
   fXaxis.SetLabelSize(xLabelSize);
   fXaxis.SetTickLength(xTickLength);
   fXaxis.SetTitleOffset(xTitleOffset);
   fXaxis.SetTitleSize(xTitleSize);
   fXaxis.SetTitleColor(xTitleColor);
   fXaxis.SetTitleFont(xTitleFont);
   // Restore y axis attributes
   fYaxis.SetNdivisions(nYdivisions);
   fYaxis.SetAxisColor(yAxisColor);
   fYaxis.SetLabelColor(yLabelColor);
   fYaxis.SetLabelFont(yLabelFont);
   fYaxis.SetLabelOffset(yLabelOffset);
   fYaxis.SetLabelSize(yLabelSize);
   fYaxis.SetTickLength(yTickLength);
   fYaxis.SetTitleOffset(yTitleOffset);
   fYaxis.SetTitleSize(yTitleSize);
   fYaxis.SetTitleColor(yTitleColor);
   fYaxis.SetTitleFont(yTitleFont);

   if (resetStat) hnew->ResetStats();

   delete [] oldBins;
   if (oldErrors) delete [] oldErrors;
   return hnew;
}


//______________________________________________________________________________
TProfile *TH2::DoProfile(bool onX, const char *name, Int_t firstbin, Int_t lastbin, Option_t *option) const
{
   TString opt = option;
   // extract cut infor
   TString cut;
   Int_t i1 = opt.Index("[");
   if (i1>=0) {
      Int_t i2 = opt.Index("]");
      cut = opt(i1,i2-i1+1);
   }
   opt.ToLower();
   bool originalRange = opt.Contains("o");

   const TAxis& outAxis = ( onX ? fXaxis : fYaxis );
   const TAxis&  inAxis = ( onX ? fYaxis : fXaxis );
   Int_t  inN = inAxis.GetNbins();
   const char *expectedName = ( onX ? "_pfx" : "_pfy" );

   Int_t firstOutBin, lastOutBin;
   firstOutBin = outAxis.GetFirst();
   lastOutBin = outAxis.GetLast();
   if (firstOutBin == 0 && lastOutBin == 0) {
      firstOutBin = 1; lastOutBin = outAxis.GetNbins();
   }

   if ( lastbin < firstbin && inAxis.TestBit(TAxis::kAxisRange) ) {
      firstbin = inAxis.GetFirst();
      lastbin = inAxis.GetLast();
      // For special case of TAxis::SetRange, when first == 1 and last
      // = N and the range bit has been set, the TAxis will return 0
      // for both.
      if (firstbin == 0 && lastbin == 0)
      {
         firstbin = 1;
         lastbin = inAxis.GetNbins();
      }
   }
   if (firstbin < 0) firstbin = 1;
   if (lastbin  < 0) lastbin  = inN;
   if (lastbin  > inN+1) lastbin  = inN;

   // Create the profile histogram
   char *pname = (char*)name;
   if (name && strcmp(name, expectedName) == 0) {
      Int_t nch = strlen(GetName()) + 5;
      pname = new char[nch];
      snprintf(pname,nch,"%s%s",GetName(),name);
   }
   TProfile *h1=0;
   //check if a profile with identical name exist
   // if compatible reset and re-use previous histogram
   TObject *h1obj = gROOT->FindObject(pname);
   if (h1obj && h1obj->InheritsFrom(TH1::Class())) {
      if (h1obj->IsA() != TProfile::Class() ) {
         Error("DoProfile","Histogram with name %s must be a TProfile and is a %s",name,h1obj->ClassName());
         return 0;
      }
      h1 = (TProfile*)h1obj;
      // reset the existing histogram and set always the new binning for the axis
      // This avoid problems when the histogram already exists and the histograms is rebinned or its range has changed
      // (see https://savannah.cern.ch/bugs/?94101 or https://savannah.cern.ch/bugs/?95808 )
      h1->Reset();
      const TArrayD *xbins = outAxis.GetXbins();
      if (xbins->fN == 0) {
         if ( originalRange )
            h1->SetBins(outAxis.GetNbins(),outAxis.GetXmin(),outAxis.GetXmax());
         else
            h1->SetBins(lastOutBin-firstOutBin+1,outAxis.GetBinLowEdge(firstOutBin),outAxis.GetBinUpEdge(lastOutBin));
      } else {
         // case variable bins
         if (originalRange )
            h1->SetBins(outAxis.GetNbins(),xbins->fArray);
         else
            h1->SetBins(lastOutBin-firstOutBin+1,&xbins->fArray[firstOutBin-1]);
      }
   }

   Int_t ncuts = 0;
   if (opt.Contains("[")) {
      ((TH2 *)this)->GetPainter();
      if (fPainter) ncuts = fPainter->MakeCuts((char*)cut.Data());
   }

   if (!h1) {
      const TArrayD *bins = outAxis.GetXbins();
      if (bins->fN == 0) {
         if ( originalRange )
            h1 = new TProfile(pname,GetTitle(),outAxis.GetNbins(),outAxis.GetXmin(),outAxis.GetXmax(),opt);
         else
            h1 = new TProfile(pname,GetTitle(),lastOutBin-firstOutBin+1,
                              outAxis.GetBinLowEdge(firstOutBin),
                              outAxis.GetBinUpEdge(lastOutBin), opt);
      } else {
         // case variable bins
         if (originalRange )
            h1 = new TProfile(pname,GetTitle(),outAxis.GetNbins(),bins->fArray,opt);
         else
            h1 = new TProfile(pname,GetTitle(),lastOutBin-firstOutBin+1,&bins->fArray[firstOutBin-1],opt);
      }
   }
   if (pname != name)  delete [] pname;

   // Copy attributes
   h1->GetXaxis()->ImportAttributes( &outAxis);
   h1->SetLineColor(this->GetLineColor());
   h1->SetFillColor(this->GetFillColor());
   h1->SetMarkerColor(this->GetMarkerColor());
   h1->SetMarkerStyle(this->GetMarkerStyle());

   // check if histogram is weighted
   // in case need to store sum of weight square/bin for the profile
   bool useWeights = (GetSumw2N() > 0);
   if (useWeights) h1->Sumw2();
   // we need to set this bit because we fill the profile using a single Fill for many entries
   // This is needed for the changes applied to make automaticall y hthe histogram weighted in ROOT 6 versions
   else h1->SetBit(TH1::kIsNotW);  

   // Fill the profile histogram
   // no entries/bin is available so can fill only using bin content as weight
   Double_t totcont = 0;
   TArrayD & binSumw2 = *(h1->GetBinSumw2());

   // implement filling of projected histogram
   // outbin is bin number of outAxis (the projected axis). Loop is done on all bin of TH2 histograms
   // inbin is the axis being integrated. Loop is done only on the selected bins
   for ( Int_t outbin = 0; outbin <= outAxis.GetNbins() + 1;  ++outbin) {
      if (outAxis.TestBit(TAxis::kAxisRange) && ( outbin < firstOutBin || outbin > lastOutBin )) continue;

      // find corresponding bin number in h1 for outbin (binOut)
      Double_t xOut = outAxis.GetBinCenter(outbin);
      Int_t binOut = h1->GetXaxis()->FindBin( xOut );
      if (binOut <0) continue;

      for (Int_t inbin = firstbin ; inbin <= lastbin ; ++inbin) {
         Int_t binx, biny;
         if (onX) { binx = outbin; biny=inbin; }
         else     { binx = inbin;  biny=outbin; }

         if (ncuts) {
            if (!fPainter->IsInside(binx,biny)) continue;
         }
         Int_t bin = GetBin(binx, biny);
         Double_t cxy = RetrieveBinContent(bin);


         if (cxy) {
            Double_t tmp = 0;
            // the following fill update wrongly the fBinSumw2- need to save it before
            if ( useWeights ) tmp = binSumw2.fArray[binOut];
            h1->Fill( xOut, inAxis.GetBinCenter(inbin), cxy );
            if ( useWeights ) binSumw2.fArray[binOut] = tmp + fSumw2.fArray[bin];
            totcont += cxy;
         }

      }
   }

   // the statistics must be recalculated since by using the Fill method the total sum of weight^2 is
   // not computed correctly
   // for a profile does not much sense to re-use statistics of original TH2
   h1->ResetStats();
   // Also we need to set the entries since they have not been correctly calculated during the projection
   // we can only set them to the effective entries
   h1->SetEntries( h1->GetEffectiveEntries() );


   if (opt.Contains("d")) {
      TVirtualPad *padsav = gPad;
      TVirtualPad *pad = gROOT->GetSelectedPad();
      if (pad) pad->cd();
      opt.Remove(opt.First("d"),1);
      if (!gPad || !gPad->FindObject(h1)) {
         h1->Draw(opt);
      } else {
         h1->Paint(opt);
      }
      if (padsav) padsav->cd();
   }
   return h1;
}


//______________________________________________________________________________
TProfile *TH2::ProfileX(const char *name, Int_t firstybin, Int_t lastybin, Option_t *option) const
{
   // Project a 2-D histogram into a profile histogram along X.
   //
   //   The projection is made from the channels along the Y axis
   //   ranging from firstybin to lastybin included.
   //   By default, bins 1 to ny are included
   //   When all bins are included, the number of entries in the projection
   //   is set to the number of entries of the 2-D histogram, otherwise
   //   the number of entries is incremented by 1 for all non empty cells.
   //
   //   if option "d" is specified, the profile is drawn in the current pad.
   //
   //   if option "o" original axis range of the target axes will be
   //   kept, but only bins inside the selected range will be filled.
   //
   //   The option can also be used to specify the projected profile error type.
   //   Values which can be used are 's', 'i', or 'g'. See TProfile::BuildOptions for details
   //
   //   Using a TCutG object, it is possible to select a sub-range of a 2-D histogram.
   //   One must create a graphical cut (mouse or C++) and specify the name
   //   of the cut between [] in the option.
   //   For example, with a TCutG named "cutg", one can call:
   //      myhist->ProfileX(" ",firstybin,lastybin,"[cutg]");
   //   To invert the cut, it is enough to put a "-" in front of its name:
   //      myhist->ProfileX(" ",firstybin,lastybin,"[-cutg]");
   //   It is possible to apply several cuts ("," means logical AND):
   //      myhist->ProfileX(" ",firstybin,lastybin,"[cutg1,cutg2]");
   //
   //   NOTE that if a TProfile named "name" exists in the current directory or pad with
   //   a compatible axis the profile is reset and filled again with the projected contents of the TH2.
   //   In the case of axis incompatibility an error is reported and a NULL pointer is returned.
   //
   //   NOTE that the X axis attributes of the TH2 are copied to the X axis of the profile.
   //
   //   NOTE that the default under- / overflow behavior differs from what ProjectionX
   //   does! Profiles take the bin center into account, so here the under- and overflow
   //   bins are ignored by default.

   return DoProfile(true, name, firstybin, lastybin, option);

}


//______________________________________________________________________________
TProfile *TH2::ProfileY(const char *name, Int_t firstxbin, Int_t lastxbin, Option_t *option) const
{
   // Project a 2-D histogram into a profile histogram along Y.
   //
   //   The projection is made from the channels along the X axis
   //   ranging from firstxbin to lastxbin included.
   //   By default, bins 1 to nx are included
   //   When all bins are included, the number of entries in the projection
   //   is set to the number of entries of the 2-D histogram, otherwise
   //   the number of entries is incremented by 1 for all non empty cells.
   //
   //   if option "d" is specified, the profile is drawn in the current pad.
   //
   //   if option "o" , the original axis range of the target axis will be
   //   kept, but only bins inside the selected range will be filled.
   //
   //   The option can also be used to specify the projected profile error type.
   //   Values which can be used are 's', 'i', or 'g'. See TProfile::BuildOptions for details
   //   Using a TCutG object, it is possible to select a sub-range of a 2-D histogram.
   //
   //   One must create a graphical cut (mouse or C++) and specify the name
   //   of the cut between [] in the option.
   //   For example, with a TCutG named "cutg", one can call:
   //      myhist->ProfileY(" ",firstybin,lastybin,"[cutg]");
   //   To invert the cut, it is enough to put a "-" in front of its name:
   //      myhist->ProfileY(" ",firstybin,lastybin,"[-cutg]");
   //   It is possible to apply several cuts:
   //      myhist->ProfileY(" ",firstybin,lastybin,"[cutg1,cutg2]");
   //
   //   NOTE that if a TProfile named "name" exists in the current directory or pad with
   //   a compatible axis the profile is reset and filled again with the projected contents of the TH2.
   //   In the case of axis incompatibility an error is reported and a NULL pointer is returned.
   //
   //   NOTE that the Y axis attributes of the TH2 are copied to the X axis of the profile.
   //
   //   NOTE that the default under- / overflow behavior differs from what ProjectionX
   //   does! Profiles take the bin center into account, so here the under- and overflow
   //   bins are ignored by default.

   return DoProfile(false, name, firstxbin, lastxbin, option);
}


//______________________________________________________________________________
TH1D *TH2::DoProjection(bool onX, const char *name, Int_t firstbin, Int_t lastbin, Option_t *option) const
{
   // Internal (protected) method for performing projection on the X or Y axis
   // called by ProjectionX or ProjectionY

   const char *expectedName = 0;
   Int_t inNbin;
   Int_t firstOutBin, lastOutBin;
   const TAxis* outAxis;
   const TAxis* inAxis;

   TString opt = option;
   TString cut;
   Int_t i1 = opt.Index("[");
   if (i1>=0) {
      Int_t i2 = opt.Index("]");
      cut = opt(i1,i2-i1+1);
   }
   opt.ToLower();  //must be called after having parsed the cut name
   bool originalRange = opt.Contains("o");

   if ( onX )
   {
      expectedName = "_px";
      inNbin = fYaxis.GetNbins();
      outAxis = GetXaxis();
      inAxis = GetYaxis();
   }
   else
   {
      expectedName = "_py";
      inNbin = fXaxis.GetNbins();
      outAxis = GetYaxis();
      inAxis = GetXaxis();
   }

   firstOutBin = outAxis->GetFirst();
   lastOutBin = outAxis->GetLast();
   if (firstOutBin == 0 && lastOutBin == 0) {
      firstOutBin = 1; lastOutBin = outAxis->GetNbins();
   }

   if ( lastbin < firstbin && inAxis->TestBit(TAxis::kAxisRange) ) {
      firstbin = inAxis->GetFirst();
      lastbin = inAxis->GetLast();
      // For special case of TAxis::SetRange, when first == 1 and last
      // = N and the range bit has been set, the TAxis will return 0
      // for both.
      if (firstbin == 0 && lastbin == 0)
      {
         firstbin = 1;
         lastbin = inAxis->GetNbins();
      }
   }
   if (firstbin < 0) firstbin = 0;
   if (lastbin  < 0) lastbin  = inNbin + 1;
   if (lastbin  > inNbin+1) lastbin  = inNbin + 1;

   // Create the projection histogram
   char *pname = (char*)name;
   if (name && strcmp(name,expectedName) == 0) {
      Int_t nch = strlen(GetName()) + 4;
      pname = new char[nch];
      snprintf(pname,nch,"%s%s",GetName(),name);
   }
   TH1D *h1=0;
   //check if histogram with identical name exist
   // if compatible reset and re-use previous histogram
   // (see https://savannah.cern.ch/bugs/?54340)
   TObject *h1obj = gROOT->FindObject(pname);
   if (h1obj && h1obj->InheritsFrom(TH1::Class())) {
      if (h1obj->IsA() != TH1D::Class() ) {
         Error("DoProjection","Histogram with name %s must be a TH1D and is a %s",name,h1obj->ClassName());
         return 0;
      }
      h1 = (TH1D*)h1obj;
      // reset the existing histogram and set always the new binning for the axis
      // This avoid problems when the histogram already exists and the histograms is rebinned or its range has changed
      // (see https://savannah.cern.ch/bugs/?94101 or https://savannah.cern.ch/bugs/?95808 )
      h1->Reset();
      const TArrayD *xbins = outAxis->GetXbins();
      if (xbins->fN == 0) {
         if ( originalRange )
            h1->SetBins(outAxis->GetNbins(),outAxis->GetXmin(),outAxis->GetXmax());
         else
            h1->SetBins(lastOutBin-firstOutBin+1,outAxis->GetBinLowEdge(firstOutBin),outAxis->GetBinUpEdge(lastOutBin));
      } else {
         // case variable bins
         if (originalRange )
            h1->SetBins(outAxis->GetNbins(),xbins->fArray);
         else
            h1->SetBins(lastOutBin-firstOutBin+1,&xbins->fArray[firstOutBin-1]);
      }
   }

   Int_t ncuts = 0;
   if (opt.Contains("[")) {
      ((TH2 *)this)->GetPainter();
      if (fPainter) ncuts = fPainter->MakeCuts((char*)cut.Data());
   }

   if (!h1) {
      const TArrayD *bins = outAxis->GetXbins();
      if (bins->fN == 0) {
         if ( originalRange )
            h1 = new TH1D(pname,GetTitle(),outAxis->GetNbins(),outAxis->GetXmin(),outAxis->GetXmax());
         else
            h1 = new TH1D(pname,GetTitle(),lastOutBin-firstOutBin+1,
                          outAxis->GetBinLowEdge(firstOutBin),outAxis->GetBinUpEdge(lastOutBin));
      } else {
         // case variable bins
         if (originalRange )
            h1 = new TH1D(pname,GetTitle(),outAxis->GetNbins(),bins->fArray);
         else
            h1 = new TH1D(pname,GetTitle(),lastOutBin-firstOutBin+1,&bins->fArray[firstOutBin-1]);
      }
      if (opt.Contains("e") || GetSumw2N() ) h1->Sumw2();
   }
   if (pname != name)  delete [] pname;

   // Copy the axis attributes and the axis labels if needed.
   h1->GetXaxis()->ImportAttributes(outAxis);
   THashList* labels=outAxis->GetLabels();
   if (labels) {
      TIter iL(labels);
      TObjString* lb;
      Int_t i = 1;
      while ((lb=(TObjString*)iL())) {
         h1->GetXaxis()->SetBinLabel(i,lb->String().Data());
         i++;
      }
   }

   h1->SetLineColor(this->GetLineColor());
   h1->SetFillColor(this->GetFillColor());
   h1->SetMarkerColor(this->GetMarkerColor());
   h1->SetMarkerStyle(this->GetMarkerStyle());

   // Fill the projected histogram
   Double_t cont,err2;
   Double_t totcont = 0;
   Bool_t  computeErrors = h1->GetSumw2N();

   // implement filling of projected histogram
   // outbin is bin number of outAxis (the projected axis). Loop is done on all bin of TH2 histograms
   // inbin is the axis being integrated. Loop is done only on the selected bins
   for ( Int_t outbin = 0; outbin <= outAxis->GetNbins() + 1;  ++outbin) {
      err2 = 0;
      cont = 0;
      if (outAxis->TestBit(TAxis::kAxisRange) && ( outbin < firstOutBin || outbin > lastOutBin )) continue;

      for (Int_t inbin = firstbin ; inbin <= lastbin ; ++inbin) {
         Int_t binx, biny;
         if (onX) { binx = outbin; biny=inbin; }
         else     { binx = inbin;  biny=outbin; }

         if (ncuts) {
            if (!fPainter->IsInside(binx,biny)) continue;
         }
         // sum bin content and error if needed
         cont  += GetBinContent(binx,biny);
         if (computeErrors) {
            Double_t exy = GetBinError(binx,biny);
            err2  += exy*exy;
         }
      }
      // find corresponding bin number in h1 for outbin
      Int_t binOut = h1->GetXaxis()->FindBin( outAxis->GetBinCenter(outbin) );
      h1->SetBinContent(binOut ,cont);
      if (computeErrors) h1->SetBinError(binOut,TMath::Sqrt(err2));
      // sum  all content
      totcont += cont;
   }

   // check if we can re-use the original statistics from  the previous histogram
   bool reuseStats = false;
   if ( ( fgStatOverflows == false && firstbin == 1 && lastbin == inNbin     ) ||
        ( fgStatOverflows == true  && firstbin == 0 && lastbin == inNbin + 1 ) )
      reuseStats = true;
   else {
      // also if total content match we can re-use
      double eps = 1.E-12;
      if (IsA() == TH2F::Class() ) eps = 1.E-6;
      if (fTsumw != 0 && TMath::Abs( fTsumw - totcont) <  TMath::Abs(fTsumw) * eps)
         reuseStats = true;
   }
   if (ncuts) reuseStats = false;
   // retrieve  the statistics and set in projected histogram if we can re-use it
   bool reuseEntries = reuseStats;
   // can re-use entries if underflow/overflow are included
   reuseEntries &= (firstbin==0 && lastbin == inNbin+1);
   if (reuseStats) {
      Double_t stats[kNstat];
      GetStats(stats);
      if (!onX) {  // case of projection on Y
         stats[2] = stats[4];
         stats[3] = stats[5];
      }
      h1->PutStats(stats);
   }
   else {
      // the statistics is automatically recalulated since it is reset by the call to SetBinContent
      // we just need to set the entries since they have not been correctly calculated during the projection
      // we can only set them to the effective entries
      h1->SetEntries( h1->GetEffectiveEntries() );
   }
   if (reuseEntries) {
      h1->SetEntries(fEntries);
   }
   else {
      // re-compute the entries
      // in case of error calculation (i.e. when Sumw2() is set)
      // use the effective entries for the entries
      // since this  is the only way to estimate them
      Double_t entries =  TMath::Floor( totcont + 0.5); // to avoid numerical rounding
      if (h1->GetSumw2N()) entries = h1->GetEffectiveEntries();
      h1->SetEntries( entries );
   }

   if (opt.Contains("d")) {
      TVirtualPad *padsav = gPad;
      TVirtualPad *pad = gROOT->GetSelectedPad();
      if (pad) pad->cd();
      opt.Remove(opt.First("d"),1);
      // remove also other options
      if (opt.Contains("e")) opt.Remove(opt.First("e"),1);
      if (!gPad || !gPad->FindObject(h1)) {
         h1->Draw(opt);
      } else {
         h1->Paint(opt);
      }
      if (padsav) padsav->cd();
   }

   return h1;
}


//______________________________________________________________________________
TH1D *TH2::ProjectionX(const char *name, Int_t firstybin, Int_t lastybin, Option_t *option) const
{
   // Project a 2-D histogram into a 1-D histogram along X.
   //
   //   The projection is always of the type TH1D.
   //   The projection is made from the channels along the Y axis
   //   ranging from firstybin to lastybin included.
   //   By default, all bins including under- and overflow are included.
   //   The number of entries in the projection is estimated from the
   //   number of effective entries for all the cells included in the projection.
   //
   //   To exclude the underflow bins in Y, use firstybin=1.
   //   To exclude the overflow bins in Y, use lastybin=nx.
   //
   //   if option "e" is specified, the errors are computed.
   //   if option "d" is specified, the projection is drawn in the current pad.
   //   if option "o" original axis range of the taget axes will be
   //   kept, but only bins inside the selected range will be filled.
   //
   //   Using a TCutG object, it is possible to select a sub-range of a 2-D histogram.
   //   One must create a graphical cut (mouse or C++) and specify the name
   //   of the cut between [] in the option.
   //   For example, with a TCutG named "cutg", one can call:
   //      myhist->ProjectionX(" ",firstybin,lastybin,"[cutg]");
   //   To invert the cut, it is enough to put a "-" in front of its name:
   //      myhist->ProjectionX(" ",firstybin,lastybin,"[-cutg]");
   //   It is possible to apply several cuts:
   //      myhist->ProjectionX(" ",firstybin,lastybin,"[cutg1,cutg2]");
   //
   //   NOTE that if a TH1D named "name" exists in the current directory or pad
   //   the histogram is reset and filled again with the projected contents of the TH2.
   //
   //   NOTE that the X axis attributes of the TH2 are copied to the X axis of the projection.

   return DoProjection(true, name, firstybin, lastybin, option);
}


//______________________________________________________________________________
TH1D *TH2::ProjectionY(const char *name, Int_t firstxbin, Int_t lastxbin, Option_t *option) const
{
   // Project a 2-D histogram into a 1-D histogram along Y.
   //
   //   The projection is always of the type TH1D.
   //   The projection is made from the channels along the X axis
   //   ranging from firstxbin to lastxbin included.
   //   By default, all bins including under- and overflow are included.
   //   The number of entries in the projection is estimated from the
   //   number of effective entries for all the cells included in the projection
   //
   //   To exclude the underflow bins in X, use firstxbin=1.
   //   To exclude the oveerflow bins in X, use lastxbin=nx.
   //
   //   if option "e" is specified, the errors are computed.
   //   if option "d" is specified, the projection is drawn in the current pad.
   //   if option "o" original axis range of the taget axes will be
   //   kept, but only bins inside the selected range will be filled.
   //
   //   Using a TCutG object, it is possible to select a sub-range of a 2-D histogram.
   //   One must create a graphical cut (mouse or C++) and specify the name
   //   of the cut between [] in the option.
   //   For example, with a TCutG named "cutg", one can call:
   //      myhist->ProjectionY(" ",firstxbin,lastxbin,"[cutg]");
   //   To invert the cut, it is enough to put a "-" in front of its name:
   //      myhist->ProjectionY(" ",firstxbin,lastxbin,"[-cutg]");
   //   It is possible to apply several cuts:
   //      myhist->ProjectionY(" ",firstxbin,lastxbin,"[cutg1,cutg2]");
   //
   //   NOTE that if a TH1D named "name" exists in the current directory or pad and having
   //   a compatible axis, the histogram is reset and filled again with the projected contents of the TH2.
   //   In the case of axis incompatibility, an error is reported and a NULL pointer is returned.
   //
   //   NOTE that the Y axis attributes of the TH2 are copied to the X axis of the projection.

   return DoProjection(false, name, firstxbin, lastxbin, option);
}


//______________________________________________________________________________
void TH2::PutStats(Double_t *stats)
{
   // Replace current statistics with the values in array stats

   TH1::PutStats(stats);
   fTsumwy  = stats[4];
   fTsumwy2 = stats[5];
   fTsumwxy = stats[6];
}


//______________________________________________________________________________
TH1D* TH2::QuantilesX( Double_t prob, const char * name) const
{
   // Compute the X distribution of quantiles in the other variable Y
   // name is the name of the returned histogram
   // prob is the probability content for the quantile (0.5 is the default for the median)
   // An approximate error for the quantile is computed assuming that the distribution in
   // the other variable is normal.

   return DoQuantiles(true, name, prob);
}


//______________________________________________________________________________
TH1D* TH2::QuantilesY( Double_t prob, const char * name) const
{
   // Compute the Y distribution of quantiles in the other variable X
   // name is the name of the returned histogram
   // prob is the probability content for the quantile (0.5 is the default for the median)
   // An approximate error for the quantile is computed assuming that the distribution in
   // the other variable is normal.

   return DoQuantiles(false, name, prob);
}


//______________________________________________________________________________
TH1D* TH2::DoQuantiles(bool onX, const char * name, Double_t prob) const
{
   // Implementation of quantiles for x or y

   const TAxis *outAxis = 0;
   const TAxis *inAxis = 0;
   if ( onX )   {
      outAxis = GetXaxis();
      inAxis = GetYaxis();
   }  else {
      outAxis = GetYaxis();
      inAxis = GetXaxis();
   }

   // build first name of returned histogram
   TString qname = name;
   if (qname.IsNull() || qname == "_qx" || qname == "_qy") {
      const char * qtype = (onX) ? "qx" : "qy";
      qname = TString::Format("%s_%s_%3.2f",GetName(),qtype, prob);
   }
   // check if the histogram is already existing
   TH1D *h1=0;
   //check if histogram with identical name exist
   TObject *h1obj = gROOT->FindObject(qname);
   if (h1obj) {
      h1 = dynamic_cast<TH1D*>(h1obj);
      if (!h1) {
         Error("DoQuantiles","Histogram with name %s must be a TH1D and is a %s",qname.Data(),h1obj->ClassName());
         return 0;
      }
   }
   if (h1) {
      h1->Reset();
   } else {
      // create the histogram
      h1 = new TH1D(qname, GetTitle(), 1, 0, 1);
   }
   // set the bin content
   Int_t firstOutBin = outAxis->GetFirst();
   Int_t lastOutBin = outAxis->GetLast();
   const TArrayD *xbins = outAxis->GetXbins();
   if (xbins->fN == 0)
      h1->SetBins(lastOutBin-firstOutBin+1,outAxis->GetBinLowEdge(firstOutBin),outAxis->GetBinUpEdge(lastOutBin));
   else
      h1->SetBins(lastOutBin-firstOutBin+1,&xbins->fArray[firstOutBin-1]);

   // set the bin content of the histogram
  Double_t pp[1];
  pp[0] = prob;

  TH1D * slice = 0;
  for (int ibin = inAxis->GetFirst() ; ibin <= inAxis->GetLast() ; ++ibin) {
    Double_t qq[1];
    // do a projection on the opposite axis
    slice = DoProjection(!onX, "tmp",ibin,ibin,"");
    if (!slice) break;
    if (slice->GetSum() == 0) continue;
    slice->GetQuantiles(1,qq,pp);
    h1->SetBinContent(ibin,qq[0]);
    // compute error using normal approximation
    // quantile error  ~  sqrt (q*(1-q)/ *( n * f(xq) ) from Kendall
    // where f(xq) is the p.d.f value at the quantile xqp
    Double_t n = slice->GetEffectiveEntries();
    Double_t f = TMath::Gaus(qq[0], slice->GetRMS(), kTRUE);
    Double_t error = TMath::Sqrt( prob*(1.-prob)/ ( n * f) );
    h1->SetBinError(ibin, error);
  }
  if (slice) delete slice;
  return h1;
}


//______________________________________________________________________________
void TH2::Reset(Option_t *option)
{
   // Reset this histogram: contents, errors, etc.

   TH1::Reset(option);
   TString opt = option;
   opt.ToUpper();

   if (opt.Contains("ICE") && !opt.Contains("S")) return;
   fTsumwy  = 0;
   fTsumwy2 = 0;
   fTsumwxy = 0;
}


//______________________________________________________________________________
void TH2::SetBinContent(Int_t bin, Double_t content)
{
   // Set bin content
   fEntries++;
   fTsumw = 0;
   if (bin < 0) return;
   if (bin >= fNcells) return;
   UpdateBinContent(bin, content);
}


//______________________________________________________________________________
void TH2::SetShowProjectionX(Int_t nbins)
{
   // When the mouse is moved in a pad containing a 2-d view of this histogram
   // a second canvas shows the projection along X corresponding to the
   // mouse position along Y.
   // To stop the generation of the projections, delete the canvas
   // containing the projection.

   GetPainter();

   if (fPainter) fPainter->SetShowProjection("x",nbins);
}


//______________________________________________________________________________
void TH2::SetShowProjectionY(Int_t nbins)
{
   // When the mouse is moved in a pad containing a 2-d view of this histogram
   // a second canvas shows the projection along Y corresponding to the
   // mouse position along X.
   // To stop the generation of the projections, delete the canvas
   // containing the projection.

   GetPainter();

   if (fPainter) fPainter->SetShowProjection("y",nbins);
}


//______________________________________________________________________________
TH1 *TH2::ShowBackground(Int_t niter, Option_t *option)
{
   //   This function calculates the background spectrum in this histogram.
   //   The background is returned as a histogram.
   //   to be implemented (may be)


   return (TH1*)gROOT->ProcessLineFast(Form("TSpectrum2::StaticBackground((TH1*)0x%lx,%d,\"%s\")",
                                            (ULong_t)this, niter, option));
}


//______________________________________________________________________________
Int_t TH2::ShowPeaks(Double_t sigma, Option_t *option, Double_t threshold)
{
   //Interface to TSpectrum2::Search
   //the function finds peaks in this histogram where the width is > sigma
   //and the peak maximum greater than threshold*maximum bin content of this.
   //for more detauils see TSpectrum::Search.
   //note the difference in the default value for option compared to TSpectrum2::Search
   //option="" by default (instead of "goff")


   return (Int_t)gROOT->ProcessLineFast(Form("TSpectrum2::StaticSearch((TH1*)0x%lx,%g,\"%s\",%g)",
                                             (ULong_t)this, sigma, option, threshold));
}


//______________________________________________________________________________
void TH2::Smooth(Int_t ntimes, Option_t *option)
{
   // Smooth bin contents of this 2-d histogram using kernel algorithms
   // similar to the ones used in the raster graphics community.
   // Bin contents in the active range are replaced by their smooth values.
   // If Errors are defined via Sumw2, they are also scaled and computed.
   // However, note the resulting errors will be correlated between different-bins, so
   // the errors should not be used blindly to perform any calculation involving several bins,
   // like fitting the histogram.  One would need to compute also the bin by bin correlation matrix.
   //
   // 3 kernels are proposed k5a, k5b and k3a.
   // k5a and k5b act on 5x5 cells (i-2,i-1,i,i+1,i+2, and same for j)
   // k5b is a bit more stronger in smoothing
   // k3a acts only on 3x3 cells (i-1,i,i+1, and same for j).
   // By default the kernel "k5a" is used. You can select the kernels "k5b" or "k3a"
   // via the option argument.
   // If TAxis::SetRange has been called on the x or/and y axis, only the bins
   // in the specified range are smoothed.
   // In the current implementation if the first argument is not used (default value=1).
   //
   // implementation by David McKee (dmckee@bama.ua.edu). Extended by Rene Brun

   Double_t k5a[5][5] =  { { 0, 0, 1, 0, 0 },
                           { 0, 2, 2, 2, 0 },
                           { 1, 2, 5, 2, 1 },
                           { 0, 2, 2, 2, 0 },
                           { 0, 0, 1, 0, 0 } };
   Double_t k5b[5][5] =  { { 0, 1, 2, 1, 0 },
                           { 1, 2, 4, 2, 1 },
                           { 2, 4, 8, 4, 2 },
                           { 1, 2, 4, 2, 1 },
                           { 0, 1, 2, 1, 0 } };
   Double_t k3a[3][3] =  { { 0, 1, 0 },
                           { 1, 2, 1 },
                           { 0, 1, 0 } };

   if (ntimes > 1) {
      Warning("Smooth","Currently only ntimes=1 is supported");
   }
   TString opt = option;
   opt.ToLower();
   Int_t ksize_x=5;
   Int_t ksize_y=5;
   Double_t *kernel = &k5a[0][0];
   if (opt.Contains("k5b")) kernel = &k5b[0][0];
   if (opt.Contains("k3a")) {
      kernel = &k3a[0][0];
      ksize_x=3;
      ksize_y=3;
   }

   // find i,j ranges
   Int_t ifirst = fXaxis.GetFirst();
   Int_t ilast  = fXaxis.GetLast();
   Int_t jfirst = fYaxis.GetFirst();
   Int_t jlast  = fYaxis.GetLast();

   // Determine the size of the bin buffer(s) needed
   Double_t nentries = fEntries;
   Int_t nx = GetNbinsX();
   Int_t ny = GetNbinsY();
   Int_t bufSize  = (nx+2)*(ny+2);
   Double_t *buf  = new Double_t[bufSize];
   Double_t *ebuf = 0;
   if (fSumw2.fN) ebuf = new Double_t[bufSize];

   // Copy all the data to the temporary buffers
   Int_t i,j,bin;
   for (i=ifirst; i<=ilast; i++){
      for (j=jfirst; j<=jlast; j++){
         bin = GetBin(i,j);
         buf[bin] = RetrieveBinContent(bin);
         if (ebuf) ebuf[bin]=GetBinError(bin);
      }
   }

   // Kernel tail sizes (kernel sizes must be odd for this to work!)
   Int_t x_push = (ksize_x-1)/2;
   Int_t y_push = (ksize_y-1)/2;

   // main work loop
   for (i=ifirst; i<=ilast; i++){
      for (j=jfirst; j<=jlast; j++) {
         Double_t content = 0.0;
         Double_t error = 0.0;
         Double_t norm = 0.0;

         for (Int_t n=0; n<ksize_x; n++) {
            for (Int_t m=0; m<ksize_y; m++) {
               Int_t xb = i+(n-x_push);
               Int_t yb = j+(m-y_push);
               if ( (xb >= 1) && (xb <= nx) && (yb >= 1) && (yb <= ny) ) {
                  bin = GetBin(xb,yb);
                  Double_t k = kernel[n*ksize_y +m];
                  //if ( (k != 0.0 ) && (buf[bin] != 0.0) ) { // General version probably does not want the second condition
                  if ( k != 0.0 ) {
                     norm    += k;
                     content += k*buf[bin];
                     if (ebuf) error   += k*k*ebuf[bin]*ebuf[bin];
                  }
               }
            }
         }

         if ( norm != 0.0 ) {
            SetBinContent(i,j,content/norm);
            if (ebuf) {
               error /= (norm*norm);
               SetBinError(i,j,sqrt(error));
            }
         }
      }
   }
   fEntries = nentries;

   delete [] buf;
   delete [] ebuf;
}


//______________________________________________________________________________
void TH2::Streamer(TBuffer &R__b)
{
   // Stream an object of class TH2.

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      if (R__v > 2) {
         R__b.ReadClassBuffer(TH2::Class(), this, R__v, R__s, R__c);
         return;
      }
      //====process old versions before automatic schema evolution
      TH1::Streamer(R__b);
      R__b >> fScalefactor;
      R__b >> fTsumwy;
      R__b >> fTsumwy2;
      R__b >> fTsumwxy;
      //====end of old versions

   } else {
      R__b.WriteClassBuffer(TH2::Class(),this);
   }
}


//______________________________________________________________________________
//                     TH2C methods
//  TH2C a 2-D histogram with one byte per cell (char)
//______________________________________________________________________________

ClassImp(TH2C)


//______________________________________________________________________________
TH2C::TH2C(): TH2(), TArrayC()
{
   // Constructor.
   SetBinsLength(9);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2C::~TH2C()
{
   // Destructor.
}


//______________________________________________________________________________
TH2C::TH2C(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,Double_t ylow,Double_t yup)
           :TH2(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup)
{
   // Constructor.

   TArrayC::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();

   if (xlow >= xup || ylow >= yup) SetBuffer(fgBufferSize);
}


//______________________________________________________________________________
TH2C::TH2C(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,Double_t ylow,Double_t yup)
           :TH2(name,title,nbinsx,xbins,nbinsy,ylow,yup)
{
   // Constructor.

   TArrayC::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2C::TH2C(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,const Double_t *ybins)
           :TH2(name,title,nbinsx,xlow,xup,nbinsy,ybins)
{
   // Constructor.

   TArrayC::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2C::TH2C(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,const Double_t *ybins)
           :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
{
   // Constructor.

   TArrayC::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2C::TH2C(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
           ,Int_t nbinsy,const Float_t *ybins)
           :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
{
   // Constructor.

   TArrayC::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2C::TH2C(const TH2C &h2c) : TH2(), TArrayC()
{
   // Copy constructor.

   ((TH2C&)h2c).Copy(*this);
}


//______________________________________________________________________________
void TH2C::AddBinContent(Int_t bin)
{
   // Increment bin content by 1.

   if (fArray[bin] < 127) fArray[bin]++;
}


//______________________________________________________________________________
void TH2C::AddBinContent(Int_t bin, Double_t w)
{
   // Increment bin content by w.

   Int_t newval = fArray[bin] + Int_t(w);
   if (newval > -128 && newval < 128) {fArray[bin] = Char_t(newval); return;}
   if (newval < -127) fArray[bin] = -127;
   if (newval >  127) fArray[bin] =  127;
}


//______________________________________________________________________________
void TH2C::Copy(TObject &newth2) const
{
   // Copy.

   TH2::Copy((TH2C&)newth2);
}


//______________________________________________________________________________
void TH2C::Reset(Option_t *option)
{
   // Reset this histogram: contents, errors, etc.

   TH2::Reset(option);
   TArrayC::Reset();
}


//______________________________________________________________________________
void TH2C::SetBinsLength(Int_t n)
{
   // Set total number of bins including under/overflow
   // Reallocate bin contents array

   if (n < 0) n = (fXaxis.GetNbins()+2)*(fYaxis.GetNbins()+2);
   fNcells = n;
   TArrayC::Set(n);
}


//______________________________________________________________________________
void TH2C::Streamer(TBuffer &R__b)
{
   // Stream an object of class TH2C.

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      if (R__v > 2) {
         R__b.ReadClassBuffer(TH2C::Class(), this, R__v, R__s, R__c);
         return;
      }
      //====process old versions before automatic schema evolution
      if (R__v < 2) {
         R__b.ReadVersion();
         TH1::Streamer(R__b);
         TArrayC::Streamer(R__b);
         R__b.ReadVersion();
         R__b >> fScalefactor;
         R__b >> fTsumwy;
         R__b >> fTsumwy2;
         R__b >> fTsumwxy;
      } else {
         TH2::Streamer(R__b);
         TArrayC::Streamer(R__b);
         R__b.CheckByteCount(R__s, R__c, TH2C::IsA());
      }
      //====end of old versions

   } else {
      R__b.WriteClassBuffer(TH2C::Class(),this);
   }
}


//______________________________________________________________________________
TH2C& TH2C::operator=(const TH2C &h1)
{
   // Operator =

   if (this != &h1)  ((TH2C&)h1).Copy(*this);
   return *this;
}


//______________________________________________________________________________
TH2C operator*(Float_t c1, TH2C &h1)
{
   // Operator *

   TH2C hnew = h1;
   hnew.Scale(c1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2C operator+(TH2C &h1, TH2C &h2)
{
   // Operator +

   TH2C hnew = h1;
   hnew.Add(&h2,1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2C operator-(TH2C &h1, TH2C &h2)
{
   // Operator -

   TH2C hnew = h1;
   hnew.Add(&h2,-1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2C operator*(TH2C &h1, TH2C &h2)
{
   // Operator *

   TH2C hnew = h1;
   hnew.Multiply(&h2);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2C operator/(TH2C &h1, TH2C &h2)
{
   // Operator /

   TH2C hnew = h1;
   hnew.Divide(&h2);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
//                     TH2S methods
//  TH2S a 2-D histogram with two bytes per cell (short integer)
//______________________________________________________________________________

ClassImp(TH2S)


//______________________________________________________________________________
TH2S::TH2S(): TH2(), TArrayS()
{
   // Constructor.
   SetBinsLength(9);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2S::~TH2S()
{
   // Destructor.
}


//______________________________________________________________________________
TH2S::TH2S(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,Double_t ylow,Double_t yup)
           :TH2(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup)
{
   // Constructor.

   TArrayS::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();

   if (xlow >= xup || ylow >= yup) SetBuffer(fgBufferSize);
}


//______________________________________________________________________________
TH2S::TH2S(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,Double_t ylow,Double_t yup)
           :TH2(name,title,nbinsx,xbins,nbinsy,ylow,yup)
{
   // Constructor.

   TArrayS::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2S::TH2S(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,const Double_t *ybins)
           :TH2(name,title,nbinsx,xlow,xup,nbinsy,ybins)
{
   // Constructor.

   TArrayS::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2S::TH2S(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,const Double_t *ybins)
           :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
{
   // Constructor.

   TArrayS::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2S::TH2S(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
           ,Int_t nbinsy,const Float_t *ybins)
           :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
{
   // Constructor.

   TArrayS::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2S::TH2S(const TH2S &h2s) : TH2(), TArrayS()
{
   // Copy constructor.

   ((TH2S&)h2s).Copy(*this);
}


//______________________________________________________________________________
void TH2S::AddBinContent(Int_t bin)
{
   // Increment bin content by 1.

   if (fArray[bin] < 32767) fArray[bin]++;
}


//______________________________________________________________________________
void TH2S::AddBinContent(Int_t bin, Double_t w)
{
   // Increment bin content by w.

   Int_t newval = fArray[bin] + Int_t(w);
   if (newval > -32768 && newval < 32768) {fArray[bin] = Short_t(newval); return;}
   if (newval < -32767) fArray[bin] = -32767;
   if (newval >  32767) fArray[bin] =  32767;
}


//______________________________________________________________________________
void TH2S::Copy(TObject &newth2) const
{
   // Copy.

   TH2::Copy((TH2S&)newth2);
}


//______________________________________________________________________________
void TH2S::Reset(Option_t *option)
{
   // Reset this histogram: contents, errors, etc.

   TH2::Reset(option);
   TArrayS::Reset();
}


//______________________________________________________________________________
void TH2S::SetBinsLength(Int_t n)
{
   // Set total number of bins including under/overflow
   // Reallocate bin contents array

   if (n < 0) n = (fXaxis.GetNbins()+2)*(fYaxis.GetNbins()+2);
   fNcells = n;
   TArrayS::Set(n);
}


//______________________________________________________________________________
void TH2S::Streamer(TBuffer &R__b)
{
   // Stream an object of class TH2S.

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      if (R__v > 2) {
         R__b.ReadClassBuffer(TH2S::Class(), this, R__v, R__s, R__c);
         return;
      }
      //====process old versions before automatic schema evolution
      if (R__v < 2) {
         R__b.ReadVersion();
         TH1::Streamer(R__b);
         TArrayS::Streamer(R__b);
         R__b.ReadVersion();
         R__b >> fScalefactor;
         R__b >> fTsumwy;
         R__b >> fTsumwy2;
         R__b >> fTsumwxy;
      } else {
         TH2::Streamer(R__b);
         TArrayS::Streamer(R__b);
         R__b.CheckByteCount(R__s, R__c, TH2S::IsA());
      }
      //====end of old versions

   } else {
      R__b.WriteClassBuffer(TH2S::Class(),this);
   }
}


//______________________________________________________________________________
TH2S& TH2S::operator=(const TH2S &h1)
{
   // Operator =

   if (this != &h1)  ((TH2S&)h1).Copy(*this);
   return *this;
}


//______________________________________________________________________________
TH2S operator*(Float_t c1, TH2S &h1)
{
   // Operator *

   TH2S hnew = h1;
   hnew.Scale(c1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2S operator+(TH2S &h1, TH2S &h2)
{
   // Operator +

   TH2S hnew = h1;
   hnew.Add(&h2,1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2S operator-(TH2S &h1, TH2S &h2)
{
   // Operator -

   TH2S hnew = h1;
   hnew.Add(&h2,-1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2S operator*(TH2S &h1, TH2S &h2)
{
   // Operator *

   TH2S hnew = h1;
   hnew.Multiply(&h2);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2S operator/(TH2S &h1, TH2S &h2)
{
   // Operator /

   TH2S hnew = h1;
   hnew.Divide(&h2);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
//                     TH2I methods
//  TH2I a 2-D histogram with four bytes per cell (32 bits integer)
//______________________________________________________________________________

ClassImp(TH2I)


//______________________________________________________________________________
TH2I::TH2I(): TH2(), TArrayI()
{
   // Constructor.

   SetBinsLength(9);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2I::~TH2I()
{
   // Destructor.
}


//______________________________________________________________________________
TH2I::TH2I(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,Double_t ylow,Double_t yup)
           :TH2(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup)
{
   // Constructor.

   TArrayI::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();

   if (xlow >= xup || ylow >= yup) SetBuffer(fgBufferSize);
}


//______________________________________________________________________________
TH2I::TH2I(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,Double_t ylow,Double_t yup)
           :TH2(name,title,nbinsx,xbins,nbinsy,ylow,yup)
{
   // Constructor.

   TArrayI::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2I::TH2I(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,const Double_t *ybins)
           :TH2(name,title,nbinsx,xlow,xup,nbinsy,ybins)
{
   // Constructor.

   TArrayI::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2I::TH2I(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,const Double_t *ybins)
           :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
{
   // Constructor.

   TArrayI::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2I::TH2I(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
           ,Int_t nbinsy,const Float_t *ybins)
           :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
{
   // Constructor.

   TArrayI::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2I::TH2I(const TH2I &h2i) : TH2(), TArrayI()
{
   // Copy constructor.

   ((TH2I&)h2i).Copy(*this);
}


//______________________________________________________________________________
void TH2I::AddBinContent(Int_t bin)
{
   // Increment bin content by 1.

   if (fArray[bin] < 2147483647) fArray[bin]++;
}


//______________________________________________________________________________
void TH2I::AddBinContent(Int_t bin, Double_t w)
{
   // Increment bin content by w.

   Int_t newval = fArray[bin] + Int_t(w);
   if (newval > -2147483647 && newval < 2147483647) {fArray[bin] = Int_t(newval); return;}
   if (newval < -2147483647) fArray[bin] = -2147483647;
   if (newval >  2147483647) fArray[bin] =  2147483647;
}


//______________________________________________________________________________
void TH2I::Copy(TObject &newth2) const
{
   // Copy.

   TH2::Copy((TH2I&)newth2);
}


//______________________________________________________________________________
void TH2I::Reset(Option_t *option)
{
   // Reset this histogram: contents, errors, etc.

   TH2::Reset(option);
   TArrayI::Reset();
}


//______________________________________________________________________________
void TH2I::SetBinsLength(Int_t n)
{
   // Set total number of bins including under/overflow
   // Reallocate bin contents array

   if (n < 0) n = (fXaxis.GetNbins()+2)*(fYaxis.GetNbins()+2);
   fNcells = n;
   TArrayI::Set(n);
}


//______________________________________________________________________________
TH2I& TH2I::operator=(const TH2I &h1)
{
   // Operator =

   if (this != &h1)  ((TH2I&)h1).Copy(*this);
   return *this;
}


//______________________________________________________________________________
TH2I operator*(Float_t c1, TH2I &h1)
{
   // Operator *

   TH2I hnew = h1;
   hnew.Scale(c1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2I operator+(TH2I &h1, TH2I &h2)
{
   // Operator +

   TH2I hnew = h1;
   hnew.Add(&h2,1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2I operator-(TH2I &h1, TH2I &h2)
{
   // Operator -

   TH2I hnew = h1;
   hnew.Add(&h2,-1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2I operator*(TH2I &h1, TH2I &h2)
{
   // Operator *

   TH2I hnew = h1;
   hnew.Multiply(&h2);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2I operator/(TH2I &h1, TH2I &h2)
{
   // Operator /

   TH2I hnew = h1;
   hnew.Divide(&h2);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
//                     TH2F methods
//  TH2F a 2-D histogram with four bytes per cell (float)
//______________________________________________________________________________

ClassImp(TH2F)


//______________________________________________________________________________
TH2F::TH2F(): TH2(), TArrayF()
{
   // Constructor.

   SetBinsLength(9);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2F::~TH2F()
{
   // Destructor.
}


//______________________________________________________________________________
TH2F::TH2F(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,Double_t ylow,Double_t yup)
           :TH2(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup)
{
   // Constructor.

   TArrayF::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();

   if (xlow >= xup || ylow >= yup) SetBuffer(fgBufferSize);
}


//______________________________________________________________________________
TH2F::TH2F(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,Double_t ylow,Double_t yup)
           :TH2(name,title,nbinsx,xbins,nbinsy,ylow,yup)
{
   // Constructor.

   TArrayF::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2F::TH2F(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,const Double_t *ybins)
           :TH2(name,title,nbinsx,xlow,xup,nbinsy,ybins)
{
   // Constructor.

   TArrayF::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2F::TH2F(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,const Double_t *ybins)
           :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
{
   // Constructor.

   TArrayF::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2F::TH2F(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
           ,Int_t nbinsy,const Float_t *ybins)
           :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
{
   // Constructor.

   TArrayF::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2F::TH2F(const TMatrixFBase &m)
:TH2("TMatrixFBase","",m.GetNcols(),m.GetColLwb(),1+m.GetColUpb(),m.GetNrows(),m.GetRowLwb(),1+m.GetRowUpb())
{
   // Constructor.

   TArrayF::Set(fNcells);
   Int_t ilow = m.GetRowLwb();
   Int_t iup  = m.GetRowUpb();
   Int_t jlow = m.GetColLwb();
   Int_t jup  = m.GetColUpb();
   for (Int_t i=ilow;i<=iup;i++) {
      for (Int_t j=jlow;j<=jup;j++) {
         SetBinContent(j-jlow+1,i-ilow+1,m(i,j));
      }
   }
}


//______________________________________________________________________________
TH2F::TH2F(const TH2F &h2f) : TH2(), TArrayF()
{
   // Copy constructor.

   ((TH2F&)h2f).Copy(*this);
}


//______________________________________________________________________________
void TH2F::Copy(TObject &newth2) const
{
   // Copy.

   TH2::Copy((TH2F&)newth2);
}


//______________________________________________________________________________
void TH2F::Reset(Option_t *option)
{
   // Reset this histogram: contents, errors, etc.

   TH2::Reset(option);
   TArrayF::Reset();
}


//______________________________________________________________________________
void TH2F::SetBinsLength(Int_t n)
{
   // Set total number of bins including under/overflow
   // Reallocate bin contents array

   if (n < 0) n = (fXaxis.GetNbins()+2)*(fYaxis.GetNbins()+2);
   fNcells = n;
   TArrayF::Set(n);
}


//______________________________________________________________________________
void TH2F::Streamer(TBuffer &R__b)
{
   // Stream an object of class TH2F.

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      if (R__v > 2) {
         R__b.ReadClassBuffer(TH2F::Class(), this, R__v, R__s, R__c);
         return;
      }
      //====process old versions before automatic schema evolution
      if (R__v < 2) {
         R__b.ReadVersion();
         TH1::Streamer(R__b);
         TArrayF::Streamer(R__b);
         R__b.ReadVersion();
         R__b >> fScalefactor;
         R__b >> fTsumwy;
         R__b >> fTsumwy2;
         R__b >> fTsumwxy;
      } else {
         TH2::Streamer(R__b);
         TArrayF::Streamer(R__b);
         R__b.CheckByteCount(R__s, R__c, TH2F::IsA());
      }
      //====end of old versions

   } else {
      R__b.WriteClassBuffer(TH2F::Class(),this);
   }
}


//______________________________________________________________________________
TH2F& TH2F::operator=(const TH2F &h1)
{
   // Operator =

   if (this != &h1)  ((TH2F&)h1).Copy(*this);
   return *this;
}


//______________________________________________________________________________
TH2F operator*(Float_t c1, TH2F &h1)
{
   // Operator *

   TH2F hnew = h1;
   hnew.Scale(c1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2F operator*(TH2F &h1, Float_t c1)
{
   // Operator *

   TH2F hnew = h1;
   hnew.Scale(c1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2F operator+(TH2F &h1, TH2F &h2)
{
   // Operator +

   TH2F hnew = h1;
   hnew.Add(&h2,1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2F operator-(TH2F &h1, TH2F &h2)
{
   // Operator -

   TH2F hnew = h1;
   hnew.Add(&h2,-1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2F operator*(TH2F &h1, TH2F &h2)
{
   // Operator *

   TH2F hnew = h1;
   hnew.Multiply(&h2);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2F operator/(TH2F &h1, TH2F &h2)
{
   // Operator /

   TH2F hnew = h1;
   hnew.Divide(&h2);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
//                     TH2D methods
//  TH2D a 2-D histogram with eight bytes per cell (double)
//______________________________________________________________________________

ClassImp(TH2D)


//______________________________________________________________________________
TH2D::TH2D(): TH2(), TArrayD()
{
   // Constructor.

   SetBinsLength(9);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2D::~TH2D()
{
   // Destructor.
}


//______________________________________________________________________________
TH2D::TH2D(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,Double_t ylow,Double_t yup)
           :TH2(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup)
{
   // Constructor.

   TArrayD::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();

   if (xlow >= xup || ylow >= yup) SetBuffer(fgBufferSize);
}


//______________________________________________________________________________
TH2D::TH2D(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,Double_t ylow,Double_t yup)
           :TH2(name,title,nbinsx,xbins,nbinsy,ylow,yup)
{
   // Constructor.

   TArrayD::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2D::TH2D(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,const Double_t *ybins)
           :TH2(name,title,nbinsx,xlow,xup,nbinsy,ybins)
{
   // Constructor.

   TArrayD::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2D::TH2D(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,const Double_t *ybins)
           :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
{
   // Constructor.

   TArrayD::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2D::TH2D(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
           ,Int_t nbinsy,const Float_t *ybins)
           :TH2(name,title,nbinsx,xbins,nbinsy,ybins)
{
   // Constructor.

   TArrayD::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2D::TH2D(const TMatrixDBase &m)
:TH2("TMatrixDBase","",m.GetNcols(),m.GetColLwb(),1+m.GetColUpb(),m.GetNrows(),m.GetRowLwb(),1+m.GetRowUpb())
{
   // Constructor.

   TArrayD::Set(fNcells);
   Int_t ilow = m.GetRowLwb();
   Int_t iup  = m.GetRowUpb();
   Int_t jlow = m.GetColLwb();
   Int_t jup  = m.GetColUpb();
   for (Int_t i=ilow;i<=iup;i++) {
      for (Int_t j=jlow;j<=jup;j++) {
         SetBinContent(j-jlow+1,i-ilow+1,m(i,j));
      }
   }
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH2D::TH2D(const TH2D &h2d) : TH2(), TArrayD()
{
   // Copy constructor.

   ((TH2D&)h2d).Copy(*this);
}


//______________________________________________________________________________
void TH2D::Copy(TObject &newth2) const
{
   // Copy.

   TH2::Copy((TH2D&)newth2);
}


//______________________________________________________________________________
void TH2D::Reset(Option_t *option)
{
   // Reset this histogram: contents, errors, etc.

   TH2::Reset(option);
   TArrayD::Reset();
}


//______________________________________________________________________________
void TH2D::SetBinsLength(Int_t n)
{
   // Set total number of bins including under/overflow
   // Reallocate bin contents array

   if (n < 0) n = (fXaxis.GetNbins()+2)*(fYaxis.GetNbins()+2);
   fNcells = n;
   TArrayD::Set(n);
}


//______________________________________________________________________________
void TH2D::Streamer(TBuffer &R__b)
{
   // Stream an object of class TH2D.

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      if (R__v > 2) {
         R__b.ReadClassBuffer(TH2D::Class(), this, R__v, R__s, R__c);
         return;
      }
      //====process old versions before automatic schema evolution
      if (R__v < 2) {
         R__b.ReadVersion();
         TH1::Streamer(R__b);
         TArrayD::Streamer(R__b);
         R__b.ReadVersion();
         R__b >> fScalefactor;
         R__b >> fTsumwy;
         R__b >> fTsumwy2;
         R__b >> fTsumwxy;
      } else {
         TH2::Streamer(R__b);
         TArrayD::Streamer(R__b);
         R__b.CheckByteCount(R__s, R__c, TH2D::IsA());
      }
      //====end of old versions

   } else {
      R__b.WriteClassBuffer(TH2D::Class(),this);
   }
}


//______________________________________________________________________________
TH2D& TH2D::operator=(const TH2D &h1)
{
   // Operator =

   if (this != &h1)  ((TH2D&)h1).Copy(*this);
   return *this;
}



//______________________________________________________________________________
TH2D operator*(Float_t c1, TH2D &h1)
{
   // Operator *

   TH2D hnew = h1;
   hnew.Scale(c1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2D operator+(TH2D &h1, TH2D &h2)
{
   // Operator +

   TH2D hnew = h1;
   hnew.Add(&h2,1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2D operator-(TH2D &h1, TH2D &h2)
{
   // Operator -

   TH2D hnew = h1;
   hnew.Add(&h2,-1);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2D operator*(TH2D &h1, TH2D &h2)
{
   // Operator *

   TH2D hnew = h1;
   hnew.Multiply(&h2);
   hnew.SetDirectory(0);
   return hnew;
}


//______________________________________________________________________________
TH2D operator/(TH2D &h1, TH2D &h2)
{
   // Operator /

   TH2D hnew = h1;
   hnew.Divide(&h2);
   hnew.SetDirectory(0);
   return hnew;
}
 TH2.cxx:1
 TH2.cxx:2
 TH2.cxx:3
 TH2.cxx:4
 TH2.cxx:5
 TH2.cxx:6
 TH2.cxx:7
 TH2.cxx:8
 TH2.cxx:9
 TH2.cxx:10
 TH2.cxx:11
 TH2.cxx:12
 TH2.cxx:13
 TH2.cxx:14
 TH2.cxx:15
 TH2.cxx:16
 TH2.cxx:17
 TH2.cxx:18
 TH2.cxx:19
 TH2.cxx:20
 TH2.cxx:21
 TH2.cxx:22
 TH2.cxx:23
 TH2.cxx:24
 TH2.cxx:25
 TH2.cxx:26
 TH2.cxx:27
 TH2.cxx:28
 TH2.cxx:29
 TH2.cxx:30
 TH2.cxx:31
 TH2.cxx:32
 TH2.cxx:33
 TH2.cxx:34
 TH2.cxx:35
 TH2.cxx:36
 TH2.cxx:37
 TH2.cxx:38
 TH2.cxx:39
 TH2.cxx:40
 TH2.cxx:41
 TH2.cxx:42
 TH2.cxx:43
 TH2.cxx:44
 TH2.cxx:45
 TH2.cxx:46
 TH2.cxx:47
 TH2.cxx:48
 TH2.cxx:49
 TH2.cxx:50
 TH2.cxx:51
 TH2.cxx:52
 TH2.cxx:53
 TH2.cxx:54
 TH2.cxx:55
 TH2.cxx:56
 TH2.cxx:57
 TH2.cxx:58
 TH2.cxx:59
 TH2.cxx:60
 TH2.cxx:61
 TH2.cxx:62
 TH2.cxx:63
 TH2.cxx:64
 TH2.cxx:65
 TH2.cxx:66
 TH2.cxx:67
 TH2.cxx:68
 TH2.cxx:69
 TH2.cxx:70
 TH2.cxx:71
 TH2.cxx:72
 TH2.cxx:73
 TH2.cxx:74
 TH2.cxx:75
 TH2.cxx:76
 TH2.cxx:77
 TH2.cxx:78
 TH2.cxx:79
 TH2.cxx:80
 TH2.cxx:81
 TH2.cxx:82
 TH2.cxx:83
 TH2.cxx:84
 TH2.cxx:85
 TH2.cxx:86
 TH2.cxx:87
 TH2.cxx:88
 TH2.cxx:89
 TH2.cxx:90
 TH2.cxx:91
 TH2.cxx:92
 TH2.cxx:93
 TH2.cxx:94
 TH2.cxx:95
 TH2.cxx:96
 TH2.cxx:97
 TH2.cxx:98
 TH2.cxx:99
 TH2.cxx:100
 TH2.cxx:101
 TH2.cxx:102
 TH2.cxx:103
 TH2.cxx:104
 TH2.cxx:105
 TH2.cxx:106
 TH2.cxx:107
 TH2.cxx:108
 TH2.cxx:109
 TH2.cxx:110
 TH2.cxx:111
 TH2.cxx:112
 TH2.cxx:113
 TH2.cxx:114
 TH2.cxx:115
 TH2.cxx:116
 TH2.cxx:117
 TH2.cxx:118
 TH2.cxx:119
 TH2.cxx:120
 TH2.cxx:121
 TH2.cxx:122
 TH2.cxx:123
 TH2.cxx:124
 TH2.cxx:125
 TH2.cxx:126
 TH2.cxx:127
 TH2.cxx:128
 TH2.cxx:129
 TH2.cxx:130
 TH2.cxx:131
 TH2.cxx:132
 TH2.cxx:133
 TH2.cxx:134
 TH2.cxx:135
 TH2.cxx:136
 TH2.cxx:137
 TH2.cxx:138
 TH2.cxx:139
 TH2.cxx:140
 TH2.cxx:141
 TH2.cxx:142
 TH2.cxx:143
 TH2.cxx:144
 TH2.cxx:145
 TH2.cxx:146
 TH2.cxx:147
 TH2.cxx:148
 TH2.cxx:149
 TH2.cxx:150
 TH2.cxx:151
 TH2.cxx:152
 TH2.cxx:153
 TH2.cxx:154
 TH2.cxx:155
 TH2.cxx:156
 TH2.cxx:157
 TH2.cxx:158
 TH2.cxx:159
 TH2.cxx:160
 TH2.cxx:161
 TH2.cxx:162
 TH2.cxx:163
 TH2.cxx:164
 TH2.cxx:165
 TH2.cxx:166
 TH2.cxx:167
 TH2.cxx:168
 TH2.cxx:169
 TH2.cxx:170
 TH2.cxx:171
 TH2.cxx:172
 TH2.cxx:173
 TH2.cxx:174
 TH2.cxx:175
 TH2.cxx:176
 TH2.cxx:177
 TH2.cxx:178
 TH2.cxx:179
 TH2.cxx:180
 TH2.cxx:181
 TH2.cxx:182
 TH2.cxx:183
 TH2.cxx:184
 TH2.cxx:185
 TH2.cxx:186
 TH2.cxx:187
 TH2.cxx:188
 TH2.cxx:189
 TH2.cxx:190
 TH2.cxx:191
 TH2.cxx:192
 TH2.cxx:193
 TH2.cxx:194
 TH2.cxx:195
 TH2.cxx:196
 TH2.cxx:197
 TH2.cxx:198
 TH2.cxx:199
 TH2.cxx:200
 TH2.cxx:201
 TH2.cxx:202
 TH2.cxx:203
 TH2.cxx:204
 TH2.cxx:205
 TH2.cxx:206
 TH2.cxx:207
 TH2.cxx:208
 TH2.cxx:209
 TH2.cxx:210
 TH2.cxx:211
 TH2.cxx:212
 TH2.cxx:213
 TH2.cxx:214
 TH2.cxx:215
 TH2.cxx:216
 TH2.cxx:217
 TH2.cxx:218
 TH2.cxx:219
 TH2.cxx:220
 TH2.cxx:221
 TH2.cxx:222
 TH2.cxx:223
 TH2.cxx:224
 TH2.cxx:225
 TH2.cxx:226
 TH2.cxx:227
 TH2.cxx:228
 TH2.cxx:229
 TH2.cxx:230
 TH2.cxx:231
 TH2.cxx:232
 TH2.cxx:233
 TH2.cxx:234
 TH2.cxx:235
 TH2.cxx:236
 TH2.cxx:237
 TH2.cxx:238
 TH2.cxx:239
 TH2.cxx:240
 TH2.cxx:241
 TH2.cxx:242
 TH2.cxx:243
 TH2.cxx:244
 TH2.cxx:245
 TH2.cxx:246
 TH2.cxx:247
 TH2.cxx:248
 TH2.cxx:249
 TH2.cxx:250
 TH2.cxx:251
 TH2.cxx:252
 TH2.cxx:253
 TH2.cxx:254
 TH2.cxx:255
 TH2.cxx:256
 TH2.cxx:257
 TH2.cxx:258
 TH2.cxx:259
 TH2.cxx:260
 TH2.cxx:261
 TH2.cxx:262
 TH2.cxx:263
 TH2.cxx:264
 TH2.cxx:265
 TH2.cxx:266
 TH2.cxx:267
 TH2.cxx:268
 TH2.cxx:269
 TH2.cxx:270
 TH2.cxx:271
 TH2.cxx:272
 TH2.cxx:273
 TH2.cxx:274
 TH2.cxx:275
 TH2.cxx:276
 TH2.cxx:277
 TH2.cxx:278
 TH2.cxx:279
 TH2.cxx:280
 TH2.cxx:281
 TH2.cxx:282
 TH2.cxx:283
 TH2.cxx:284
 TH2.cxx:285
 TH2.cxx:286
 TH2.cxx:287
 TH2.cxx:288
 TH2.cxx:289
 TH2.cxx:290
 TH2.cxx:291
 TH2.cxx:292
 TH2.cxx:293
 TH2.cxx:294
 TH2.cxx:295
 TH2.cxx:296
 TH2.cxx:297
 TH2.cxx:298
 TH2.cxx:299
 TH2.cxx:300
 TH2.cxx:301
 TH2.cxx:302
 TH2.cxx:303
 TH2.cxx:304
 TH2.cxx:305
 TH2.cxx:306
 TH2.cxx:307
 TH2.cxx:308
 TH2.cxx:309
 TH2.cxx:310
 TH2.cxx:311
 TH2.cxx:312
 TH2.cxx:313
 TH2.cxx:314
 TH2.cxx:315
 TH2.cxx:316
 TH2.cxx:317
 TH2.cxx:318
 TH2.cxx:319
 TH2.cxx:320
 TH2.cxx:321
 TH2.cxx:322
 TH2.cxx:323
 TH2.cxx:324
 TH2.cxx:325
 TH2.cxx:326
 TH2.cxx:327
 TH2.cxx:328
 TH2.cxx:329
 TH2.cxx:330
 TH2.cxx:331
 TH2.cxx:332
 TH2.cxx:333
 TH2.cxx:334
 TH2.cxx:335
 TH2.cxx:336
 TH2.cxx:337
 TH2.cxx:338
 TH2.cxx:339
 TH2.cxx:340
 TH2.cxx:341
 TH2.cxx:342
 TH2.cxx:343
 TH2.cxx:344
 TH2.cxx:345
 TH2.cxx:346
 TH2.cxx:347
 TH2.cxx:348
 TH2.cxx:349
 TH2.cxx:350
 TH2.cxx:351
 TH2.cxx:352
 TH2.cxx:353
 TH2.cxx:354
 TH2.cxx:355
 TH2.cxx:356
 TH2.cxx:357
 TH2.cxx:358
 TH2.cxx:359
 TH2.cxx:360
 TH2.cxx:361
 TH2.cxx:362
 TH2.cxx:363
 TH2.cxx:364
 TH2.cxx:365
 TH2.cxx:366
 TH2.cxx:367
 TH2.cxx:368
 TH2.cxx:369
 TH2.cxx:370
 TH2.cxx:371
 TH2.cxx:372
 TH2.cxx:373
 TH2.cxx:374
 TH2.cxx:375
 TH2.cxx:376
 TH2.cxx:377
 TH2.cxx:378
 TH2.cxx:379
 TH2.cxx:380
 TH2.cxx:381
 TH2.cxx:382
 TH2.cxx:383
 TH2.cxx:384
 TH2.cxx:385
 TH2.cxx:386
 TH2.cxx:387
 TH2.cxx:388
 TH2.cxx:389
 TH2.cxx:390
 TH2.cxx:391
 TH2.cxx:392
 TH2.cxx:393
 TH2.cxx:394
 TH2.cxx:395
 TH2.cxx:396
 TH2.cxx:397
 TH2.cxx:398
 TH2.cxx:399
 TH2.cxx:400
 TH2.cxx:401
 TH2.cxx:402
 TH2.cxx:403
 TH2.cxx:404
 TH2.cxx:405
 TH2.cxx:406
 TH2.cxx:407
 TH2.cxx:408
 TH2.cxx:409
 TH2.cxx:410
 TH2.cxx:411
 TH2.cxx:412
 TH2.cxx:413
 TH2.cxx:414
 TH2.cxx:415
 TH2.cxx:416
 TH2.cxx:417
 TH2.cxx:418
 TH2.cxx:419
 TH2.cxx:420
 TH2.cxx:421
 TH2.cxx:422
 TH2.cxx:423
 TH2.cxx:424
 TH2.cxx:425
 TH2.cxx:426
 TH2.cxx:427
 TH2.cxx:428
 TH2.cxx:429
 TH2.cxx:430
 TH2.cxx:431
 TH2.cxx:432
 TH2.cxx:433
 TH2.cxx:434
 TH2.cxx:435
 TH2.cxx:436
 TH2.cxx:437
 TH2.cxx:438
 TH2.cxx:439
 TH2.cxx:440
 TH2.cxx:441
 TH2.cxx:442
 TH2.cxx:443
 TH2.cxx:444
 TH2.cxx:445
 TH2.cxx:446
 TH2.cxx:447
 TH2.cxx:448
 TH2.cxx:449
 TH2.cxx:450
 TH2.cxx:451
 TH2.cxx:452
 TH2.cxx:453
 TH2.cxx:454
 TH2.cxx:455
 TH2.cxx:456
 TH2.cxx:457
 TH2.cxx:458
 TH2.cxx:459
 TH2.cxx:460
 TH2.cxx:461
 TH2.cxx:462
 TH2.cxx:463
 TH2.cxx:464
 TH2.cxx:465
 TH2.cxx:466
 TH2.cxx:467
 TH2.cxx:468
 TH2.cxx:469
 TH2.cxx:470
 TH2.cxx:471
 TH2.cxx:472
 TH2.cxx:473
 TH2.cxx:474
 TH2.cxx:475
 TH2.cxx:476
 TH2.cxx:477
 TH2.cxx:478
 TH2.cxx:479
 TH2.cxx:480
 TH2.cxx:481
 TH2.cxx:482
 TH2.cxx:483
 TH2.cxx:484
 TH2.cxx:485
 TH2.cxx:486
 TH2.cxx:487
 TH2.cxx:488
 TH2.cxx:489
 TH2.cxx:490
 TH2.cxx:491
 TH2.cxx:492
 TH2.cxx:493
 TH2.cxx:494
 TH2.cxx:495
 TH2.cxx:496
 TH2.cxx:497
 TH2.cxx:498
 TH2.cxx:499
 TH2.cxx:500
 TH2.cxx:501
 TH2.cxx:502
 TH2.cxx:503
 TH2.cxx:504
 TH2.cxx:505
 TH2.cxx:506
 TH2.cxx:507
 TH2.cxx:508
 TH2.cxx:509
 TH2.cxx:510
 TH2.cxx:511
 TH2.cxx:512
 TH2.cxx:513
 TH2.cxx:514
 TH2.cxx:515
 TH2.cxx:516
 TH2.cxx:517
 TH2.cxx:518
 TH2.cxx:519
 TH2.cxx:520
 TH2.cxx:521
 TH2.cxx:522
 TH2.cxx:523
 TH2.cxx:524
 TH2.cxx:525
 TH2.cxx:526
 TH2.cxx:527
 TH2.cxx:528
 TH2.cxx:529
 TH2.cxx:530
 TH2.cxx:531
 TH2.cxx:532
 TH2.cxx:533
 TH2.cxx:534
 TH2.cxx:535
 TH2.cxx:536
 TH2.cxx:537
 TH2.cxx:538
 TH2.cxx:539
 TH2.cxx:540
 TH2.cxx:541
 TH2.cxx:542
 TH2.cxx:543
 TH2.cxx:544
 TH2.cxx:545
 TH2.cxx:546
 TH2.cxx:547
 TH2.cxx:548
 TH2.cxx:549
 TH2.cxx:550
 TH2.cxx:551
 TH2.cxx:552
 TH2.cxx:553
 TH2.cxx:554
 TH2.cxx:555
 TH2.cxx:556
 TH2.cxx:557
 TH2.cxx:558
 TH2.cxx:559
 TH2.cxx:560
 TH2.cxx:561
 TH2.cxx:562
 TH2.cxx:563
 TH2.cxx:564
 TH2.cxx:565
 TH2.cxx:566
 TH2.cxx:567
 TH2.cxx:568
 TH2.cxx:569
 TH2.cxx:570
 TH2.cxx:571
 TH2.cxx:572
 TH2.cxx:573
 TH2.cxx:574
 TH2.cxx:575
 TH2.cxx:576
 TH2.cxx:577
 TH2.cxx:578
 TH2.cxx:579
 TH2.cxx:580
 TH2.cxx:581
 TH2.cxx:582
 TH2.cxx:583
 TH2.cxx:584
 TH2.cxx:585
 TH2.cxx:586
 TH2.cxx:587
 TH2.cxx:588
 TH2.cxx:589
 TH2.cxx:590
 TH2.cxx:591
 TH2.cxx:592
 TH2.cxx:593
 TH2.cxx:594
 TH2.cxx:595
 TH2.cxx:596
 TH2.cxx:597
 TH2.cxx:598
 TH2.cxx:599
 TH2.cxx:600
 TH2.cxx:601
 TH2.cxx:602
 TH2.cxx:603
 TH2.cxx:604
 TH2.cxx:605
 TH2.cxx:606
 TH2.cxx:607
 TH2.cxx:608
 TH2.cxx:609
 TH2.cxx:610
 TH2.cxx:611
 TH2.cxx:612
 TH2.cxx:613
 TH2.cxx:614
 TH2.cxx:615
 TH2.cxx:616
 TH2.cxx:617
 TH2.cxx:618
 TH2.cxx:619
 TH2.cxx:620
 TH2.cxx:621
 TH2.cxx:622
 TH2.cxx:623
 TH2.cxx:624
 TH2.cxx:625
 TH2.cxx:626
 TH2.cxx:627
 TH2.cxx:628
 TH2.cxx:629
 TH2.cxx:630
 TH2.cxx:631
 TH2.cxx:632
 TH2.cxx:633
 TH2.cxx:634
 TH2.cxx:635
 TH2.cxx:636
 TH2.cxx:637
 TH2.cxx:638
 TH2.cxx:639
 TH2.cxx:640
 TH2.cxx:641
 TH2.cxx:642
 TH2.cxx:643
 TH2.cxx:644
 TH2.cxx:645
 TH2.cxx:646
 TH2.cxx:647
 TH2.cxx:648
 TH2.cxx:649
 TH2.cxx:650
 TH2.cxx:651
 TH2.cxx:652
 TH2.cxx:653
 TH2.cxx:654
 TH2.cxx:655
 TH2.cxx:656
 TH2.cxx:657
 TH2.cxx:658
 TH2.cxx:659
 TH2.cxx:660
 TH2.cxx:661
 TH2.cxx:662
 TH2.cxx:663
 TH2.cxx:664
 TH2.cxx:665
 TH2.cxx:666
 TH2.cxx:667
 TH2.cxx:668
 TH2.cxx:669
 TH2.cxx:670
 TH2.cxx:671
 TH2.cxx:672
 TH2.cxx:673
 TH2.cxx:674
 TH2.cxx:675
 TH2.cxx:676
 TH2.cxx:677
 TH2.cxx:678
 TH2.cxx:679
 TH2.cxx:680
 TH2.cxx:681
 TH2.cxx:682
 TH2.cxx:683
 TH2.cxx:684
 TH2.cxx:685
 TH2.cxx:686
 TH2.cxx:687
 TH2.cxx:688
 TH2.cxx:689
 TH2.cxx:690
 TH2.cxx:691
 TH2.cxx:692
 TH2.cxx:693
 TH2.cxx:694
 TH2.cxx:695
 TH2.cxx:696
 TH2.cxx:697
 TH2.cxx:698
 TH2.cxx:699
 TH2.cxx:700
 TH2.cxx:701
 TH2.cxx:702
 TH2.cxx:703
 TH2.cxx:704
 TH2.cxx:705
 TH2.cxx:706
 TH2.cxx:707
 TH2.cxx:708
 TH2.cxx:709
 TH2.cxx:710
 TH2.cxx:711
 TH2.cxx:712
 TH2.cxx:713
 TH2.cxx:714
 TH2.cxx:715
 TH2.cxx:716
 TH2.cxx:717
 TH2.cxx:718
 TH2.cxx:719
 TH2.cxx:720
 TH2.cxx:721
 TH2.cxx:722
 TH2.cxx:723
 TH2.cxx:724
 TH2.cxx:725
 TH2.cxx:726
 TH2.cxx:727
 TH2.cxx:728
 TH2.cxx:729
 TH2.cxx:730
 TH2.cxx:731
 TH2.cxx:732
 TH2.cxx:733
 TH2.cxx:734
 TH2.cxx:735
 TH2.cxx:736
 TH2.cxx:737
 TH2.cxx:738
 TH2.cxx:739
 TH2.cxx:740
 TH2.cxx:741
 TH2.cxx:742
 TH2.cxx:743
 TH2.cxx:744
 TH2.cxx:745
 TH2.cxx:746
 TH2.cxx:747
 TH2.cxx:748
 TH2.cxx:749
 TH2.cxx:750
 TH2.cxx:751
 TH2.cxx:752
 TH2.cxx:753
 TH2.cxx:754
 TH2.cxx:755
 TH2.cxx:756
 TH2.cxx:757
 TH2.cxx:758
 TH2.cxx:759
 TH2.cxx:760
 TH2.cxx:761
 TH2.cxx:762
 TH2.cxx:763
 TH2.cxx:764
 TH2.cxx:765
 TH2.cxx:766
 TH2.cxx:767
 TH2.cxx:768
 TH2.cxx:769
 TH2.cxx:770
 TH2.cxx:771
 TH2.cxx:772
 TH2.cxx:773
 TH2.cxx:774
 TH2.cxx:775
 TH2.cxx:776
 TH2.cxx:777
 TH2.cxx:778
 TH2.cxx:779
 TH2.cxx:780
 TH2.cxx:781
 TH2.cxx:782
 TH2.cxx:783
 TH2.cxx:784
 TH2.cxx:785
 TH2.cxx:786
 TH2.cxx:787
 TH2.cxx:788
 TH2.cxx:789
 TH2.cxx:790
 TH2.cxx:791
 TH2.cxx:792
 TH2.cxx:793
 TH2.cxx:794
 TH2.cxx:795
 TH2.cxx:796
 TH2.cxx:797
 TH2.cxx:798
 TH2.cxx:799
 TH2.cxx:800
 TH2.cxx:801
 TH2.cxx:802
 TH2.cxx:803
 TH2.cxx:804
 TH2.cxx:805
 TH2.cxx:806
 TH2.cxx:807
 TH2.cxx:808
 TH2.cxx:809
 TH2.cxx:810
 TH2.cxx:811
 TH2.cxx:812
 TH2.cxx:813
 TH2.cxx:814
 TH2.cxx:815
 TH2.cxx:816
 TH2.cxx:817
 TH2.cxx:818
 TH2.cxx:819
 TH2.cxx:820
 TH2.cxx:821
 TH2.cxx:822
 TH2.cxx:823
 TH2.cxx:824
 TH2.cxx:825
 TH2.cxx:826
 TH2.cxx:827
 TH2.cxx:828
 TH2.cxx:829
 TH2.cxx:830
 TH2.cxx:831
 TH2.cxx:832
 TH2.cxx:833
 TH2.cxx:834
 TH2.cxx:835
 TH2.cxx:836
 TH2.cxx:837
 TH2.cxx:838
 TH2.cxx:839
 TH2.cxx:840
 TH2.cxx:841
 TH2.cxx:842
 TH2.cxx:843
 TH2.cxx:844
 TH2.cxx:845
 TH2.cxx:846
 TH2.cxx:847
 TH2.cxx:848
 TH2.cxx:849
 TH2.cxx:850
 TH2.cxx:851
 TH2.cxx:852
 TH2.cxx:853
 TH2.cxx:854
 TH2.cxx:855
 TH2.cxx:856
 TH2.cxx:857
 TH2.cxx:858
 TH2.cxx:859
 TH2.cxx:860
 TH2.cxx:861
 TH2.cxx:862
 TH2.cxx:863
 TH2.cxx:864
 TH2.cxx:865
 TH2.cxx:866
 TH2.cxx:867
 TH2.cxx:868
 TH2.cxx:869
 TH2.cxx:870
 TH2.cxx:871
 TH2.cxx:872
 TH2.cxx:873
 TH2.cxx:874
 TH2.cxx:875
 TH2.cxx:876
 TH2.cxx:877
 TH2.cxx:878
 TH2.cxx:879
 TH2.cxx:880
 TH2.cxx:881
 TH2.cxx:882
 TH2.cxx:883
 TH2.cxx:884
 TH2.cxx:885
 TH2.cxx:886
 TH2.cxx:887
 TH2.cxx:888
 TH2.cxx:889
 TH2.cxx:890
 TH2.cxx:891
 TH2.cxx:892
 TH2.cxx:893
 TH2.cxx:894
 TH2.cxx:895
 TH2.cxx:896
 TH2.cxx:897
 TH2.cxx:898
 TH2.cxx:899
 TH2.cxx:900
 TH2.cxx:901
 TH2.cxx:902
 TH2.cxx:903
 TH2.cxx:904
 TH2.cxx:905
 TH2.cxx:906
 TH2.cxx:907
 TH2.cxx:908
 TH2.cxx:909
 TH2.cxx:910
 TH2.cxx:911
 TH2.cxx:912
 TH2.cxx:913
 TH2.cxx:914
 TH2.cxx:915
 TH2.cxx:916
 TH2.cxx:917
 TH2.cxx:918
 TH2.cxx:919
 TH2.cxx:920
 TH2.cxx:921
 TH2.cxx:922
 TH2.cxx:923
 TH2.cxx:924
 TH2.cxx:925
 TH2.cxx:926
 TH2.cxx:927
 TH2.cxx:928
 TH2.cxx:929
 TH2.cxx:930
 TH2.cxx:931
 TH2.cxx:932
 TH2.cxx:933
 TH2.cxx:934
 TH2.cxx:935
 TH2.cxx:936
 TH2.cxx:937
 TH2.cxx:938
 TH2.cxx:939
 TH2.cxx:940
 TH2.cxx:941
 TH2.cxx:942
 TH2.cxx:943
 TH2.cxx:944
 TH2.cxx:945
 TH2.cxx:946
 TH2.cxx:947
 TH2.cxx:948
 TH2.cxx:949
 TH2.cxx:950
 TH2.cxx:951
 TH2.cxx:952
 TH2.cxx:953
 TH2.cxx:954
 TH2.cxx:955
 TH2.cxx:956
 TH2.cxx:957
 TH2.cxx:958
 TH2.cxx:959
 TH2.cxx:960
 TH2.cxx:961
 TH2.cxx:962
 TH2.cxx:963
 TH2.cxx:964
 TH2.cxx:965
 TH2.cxx:966
 TH2.cxx:967
 TH2.cxx:968
 TH2.cxx:969
 TH2.cxx:970
 TH2.cxx:971
 TH2.cxx:972
 TH2.cxx:973
 TH2.cxx:974
 TH2.cxx:975
 TH2.cxx:976
 TH2.cxx:977
 TH2.cxx:978
 TH2.cxx:979
 TH2.cxx:980
 TH2.cxx:981
 TH2.cxx:982
 TH2.cxx:983
 TH2.cxx:984
 TH2.cxx:985
 TH2.cxx:986
 TH2.cxx:987
 TH2.cxx:988
 TH2.cxx:989
 TH2.cxx:990
 TH2.cxx:991
 TH2.cxx:992
 TH2.cxx:993
 TH2.cxx:994
 TH2.cxx:995
 TH2.cxx:996
 TH2.cxx:997
 TH2.cxx:998
 TH2.cxx:999
 TH2.cxx:1000
 TH2.cxx:1001
 TH2.cxx:1002
 TH2.cxx:1003
 TH2.cxx:1004
 TH2.cxx:1005
 TH2.cxx:1006
 TH2.cxx:1007
 TH2.cxx:1008
 TH2.cxx:1009
 TH2.cxx:1010
 TH2.cxx:1011
 TH2.cxx:1012
 TH2.cxx:1013
 TH2.cxx:1014
 TH2.cxx:1015
 TH2.cxx:1016
 TH2.cxx:1017
 TH2.cxx:1018
 TH2.cxx:1019
 TH2.cxx:1020
 TH2.cxx:1021
 TH2.cxx:1022
 TH2.cxx:1023
 TH2.cxx:1024
 TH2.cxx:1025
 TH2.cxx:1026
 TH2.cxx:1027
 TH2.cxx:1028
 TH2.cxx:1029
 TH2.cxx:1030
 TH2.cxx:1031
 TH2.cxx:1032
 TH2.cxx:1033
 TH2.cxx:1034
 TH2.cxx:1035
 TH2.cxx:1036
 TH2.cxx:1037
 TH2.cxx:1038
 TH2.cxx:1039
 TH2.cxx:1040
 TH2.cxx:1041
 TH2.cxx:1042
 TH2.cxx:1043
 TH2.cxx:1044
 TH2.cxx:1045
 TH2.cxx:1046
 TH2.cxx:1047
 TH2.cxx:1048
 TH2.cxx:1049
 TH2.cxx:1050
 TH2.cxx:1051
 TH2.cxx:1052
 TH2.cxx:1053
 TH2.cxx:1054
 TH2.cxx:1055
 TH2.cxx:1056
 TH2.cxx:1057
 TH2.cxx:1058
 TH2.cxx:1059
 TH2.cxx:1060
 TH2.cxx:1061
 TH2.cxx:1062
 TH2.cxx:1063
 TH2.cxx:1064
 TH2.cxx:1065
 TH2.cxx:1066
 TH2.cxx:1067
 TH2.cxx:1068
 TH2.cxx:1069
 TH2.cxx:1070
 TH2.cxx:1071
 TH2.cxx:1072
 TH2.cxx:1073
 TH2.cxx:1074
 TH2.cxx:1075
 TH2.cxx:1076
 TH2.cxx:1077
 TH2.cxx:1078
 TH2.cxx:1079
 TH2.cxx:1080
 TH2.cxx:1081
 TH2.cxx:1082
 TH2.cxx:1083
 TH2.cxx:1084
 TH2.cxx:1085
 TH2.cxx:1086
 TH2.cxx:1087
 TH2.cxx:1088
 TH2.cxx:1089
 TH2.cxx:1090
 TH2.cxx:1091
 TH2.cxx:1092
 TH2.cxx:1093
 TH2.cxx:1094
 TH2.cxx:1095
 TH2.cxx:1096
 TH2.cxx:1097
 TH2.cxx:1098
 TH2.cxx:1099
 TH2.cxx:1100
 TH2.cxx:1101
 TH2.cxx:1102
 TH2.cxx:1103
 TH2.cxx:1104
 TH2.cxx:1105
 TH2.cxx:1106
 TH2.cxx:1107
 TH2.cxx:1108
 TH2.cxx:1109
 TH2.cxx:1110
 TH2.cxx:1111
 TH2.cxx:1112
 TH2.cxx:1113
 TH2.cxx:1114
 TH2.cxx:1115
 TH2.cxx:1116
 TH2.cxx:1117
 TH2.cxx:1118
 TH2.cxx:1119
 TH2.cxx:1120
 TH2.cxx:1121
 TH2.cxx:1122
 TH2.cxx:1123
 TH2.cxx:1124
 TH2.cxx:1125
 TH2.cxx:1126
 TH2.cxx:1127
 TH2.cxx:1128
 TH2.cxx:1129
 TH2.cxx:1130
 TH2.cxx:1131
 TH2.cxx:1132
 TH2.cxx:1133
 TH2.cxx:1134
 TH2.cxx:1135
 TH2.cxx:1136
 TH2.cxx:1137
 TH2.cxx:1138
 TH2.cxx:1139
 TH2.cxx:1140
 TH2.cxx:1141
 TH2.cxx:1142
 TH2.cxx:1143
 TH2.cxx:1144
 TH2.cxx:1145
 TH2.cxx:1146
 TH2.cxx:1147
 TH2.cxx:1148
 TH2.cxx:1149
 TH2.cxx:1150
 TH2.cxx:1151
 TH2.cxx:1152
 TH2.cxx:1153
 TH2.cxx:1154
 TH2.cxx:1155
 TH2.cxx:1156
 TH2.cxx:1157
 TH2.cxx:1158
 TH2.cxx:1159
 TH2.cxx:1160
 TH2.cxx:1161
 TH2.cxx:1162
 TH2.cxx:1163
 TH2.cxx:1164
 TH2.cxx:1165
 TH2.cxx:1166
 TH2.cxx:1167
 TH2.cxx:1168
 TH2.cxx:1169
 TH2.cxx:1170
 TH2.cxx:1171
 TH2.cxx:1172
 TH2.cxx:1173
 TH2.cxx:1174
 TH2.cxx:1175
 TH2.cxx:1176
 TH2.cxx:1177
 TH2.cxx:1178
 TH2.cxx:1179
 TH2.cxx:1180
 TH2.cxx:1181
 TH2.cxx:1182
 TH2.cxx:1183
 TH2.cxx:1184
 TH2.cxx:1185
 TH2.cxx:1186
 TH2.cxx:1187
 TH2.cxx:1188
 TH2.cxx:1189
 TH2.cxx:1190
 TH2.cxx:1191
 TH2.cxx:1192
 TH2.cxx:1193
 TH2.cxx:1194
 TH2.cxx:1195
 TH2.cxx:1196
 TH2.cxx:1197
 TH2.cxx:1198
 TH2.cxx:1199
 TH2.cxx:1200
 TH2.cxx:1201
 TH2.cxx:1202
 TH2.cxx:1203
 TH2.cxx:1204
 TH2.cxx:1205
 TH2.cxx:1206
 TH2.cxx:1207
 TH2.cxx:1208
 TH2.cxx:1209
 TH2.cxx:1210
 TH2.cxx:1211
 TH2.cxx:1212
 TH2.cxx:1213
 TH2.cxx:1214
 TH2.cxx:1215
 TH2.cxx:1216
 TH2.cxx:1217
 TH2.cxx:1218
 TH2.cxx:1219
 TH2.cxx:1220
 TH2.cxx:1221
 TH2.cxx:1222
 TH2.cxx:1223
 TH2.cxx:1224
 TH2.cxx:1225
 TH2.cxx:1226
 TH2.cxx:1227
 TH2.cxx:1228
 TH2.cxx:1229
 TH2.cxx:1230
 TH2.cxx:1231
 TH2.cxx:1232
 TH2.cxx:1233
 TH2.cxx:1234
 TH2.cxx:1235
 TH2.cxx:1236
 TH2.cxx:1237
 TH2.cxx:1238
 TH2.cxx:1239
 TH2.cxx:1240
 TH2.cxx:1241
 TH2.cxx:1242
 TH2.cxx:1243
 TH2.cxx:1244
 TH2.cxx:1245
 TH2.cxx:1246
 TH2.cxx:1247
 TH2.cxx:1248
 TH2.cxx:1249
 TH2.cxx:1250
 TH2.cxx:1251
 TH2.cxx:1252
 TH2.cxx:1253
 TH2.cxx:1254
 TH2.cxx:1255
 TH2.cxx:1256
 TH2.cxx:1257
 TH2.cxx:1258
 TH2.cxx:1259
 TH2.cxx:1260
 TH2.cxx:1261
 TH2.cxx:1262
 TH2.cxx:1263
 TH2.cxx:1264
 TH2.cxx:1265
 TH2.cxx:1266
 TH2.cxx:1267
 TH2.cxx:1268
 TH2.cxx:1269
 TH2.cxx:1270
 TH2.cxx:1271
 TH2.cxx:1272
 TH2.cxx:1273
 TH2.cxx:1274
 TH2.cxx:1275
 TH2.cxx:1276
 TH2.cxx:1277
 TH2.cxx:1278
 TH2.cxx:1279
 TH2.cxx:1280
 TH2.cxx:1281
 TH2.cxx:1282
 TH2.cxx:1283
 TH2.cxx:1284
 TH2.cxx:1285
 TH2.cxx:1286
 TH2.cxx:1287
 TH2.cxx:1288
 TH2.cxx:1289
 TH2.cxx:1290
 TH2.cxx:1291
 TH2.cxx:1292
 TH2.cxx:1293
 TH2.cxx:1294
 TH2.cxx:1295
 TH2.cxx:1296
 TH2.cxx:1297
 TH2.cxx:1298
 TH2.cxx:1299
 TH2.cxx:1300
 TH2.cxx:1301
 TH2.cxx:1302
 TH2.cxx:1303
 TH2.cxx:1304
 TH2.cxx:1305
 TH2.cxx:1306
 TH2.cxx:1307
 TH2.cxx:1308
 TH2.cxx:1309
 TH2.cxx:1310
 TH2.cxx:1311
 TH2.cxx:1312
 TH2.cxx:1313
 TH2.cxx:1314
 TH2.cxx:1315
 TH2.cxx:1316
 TH2.cxx:1317
 TH2.cxx:1318
 TH2.cxx:1319
 TH2.cxx:1320
 TH2.cxx:1321
 TH2.cxx:1322
 TH2.cxx:1323
 TH2.cxx:1324
 TH2.cxx:1325
 TH2.cxx:1326
 TH2.cxx:1327
 TH2.cxx:1328
 TH2.cxx:1329
 TH2.cxx:1330
 TH2.cxx:1331
 TH2.cxx:1332
 TH2.cxx:1333
 TH2.cxx:1334
 TH2.cxx:1335
 TH2.cxx:1336
 TH2.cxx:1337
 TH2.cxx:1338
 TH2.cxx:1339
 TH2.cxx:1340
 TH2.cxx:1341
 TH2.cxx:1342
 TH2.cxx:1343
 TH2.cxx:1344
 TH2.cxx:1345
 TH2.cxx:1346
 TH2.cxx:1347
 TH2.cxx:1348
 TH2.cxx:1349
 TH2.cxx:1350
 TH2.cxx:1351
 TH2.cxx:1352
 TH2.cxx:1353
 TH2.cxx:1354
 TH2.cxx:1355
 TH2.cxx:1356
 TH2.cxx:1357
 TH2.cxx:1358
 TH2.cxx:1359
 TH2.cxx:1360
 TH2.cxx:1361
 TH2.cxx:1362
 TH2.cxx:1363
 TH2.cxx:1364
 TH2.cxx:1365
 TH2.cxx:1366
 TH2.cxx:1367
 TH2.cxx:1368
 TH2.cxx:1369
 TH2.cxx:1370
 TH2.cxx:1371
 TH2.cxx:1372
 TH2.cxx:1373
 TH2.cxx:1374
 TH2.cxx:1375
 TH2.cxx:1376
 TH2.cxx:1377
 TH2.cxx:1378
 TH2.cxx:1379
 TH2.cxx:1380
 TH2.cxx:1381
 TH2.cxx:1382
 TH2.cxx:1383
 TH2.cxx:1384
 TH2.cxx:1385
 TH2.cxx:1386
 TH2.cxx:1387
 TH2.cxx:1388
 TH2.cxx:1389
 TH2.cxx:1390
 TH2.cxx:1391
 TH2.cxx:1392
 TH2.cxx:1393
 TH2.cxx:1394
 TH2.cxx:1395
 TH2.cxx:1396
 TH2.cxx:1397
 TH2.cxx:1398
 TH2.cxx:1399
 TH2.cxx:1400
 TH2.cxx:1401
 TH2.cxx:1402
 TH2.cxx:1403
 TH2.cxx:1404
 TH2.cxx:1405
 TH2.cxx:1406
 TH2.cxx:1407
 TH2.cxx:1408
 TH2.cxx:1409
 TH2.cxx:1410
 TH2.cxx:1411
 TH2.cxx:1412
 TH2.cxx:1413
 TH2.cxx:1414
 TH2.cxx:1415
 TH2.cxx:1416
 TH2.cxx:1417
 TH2.cxx:1418
 TH2.cxx:1419
 TH2.cxx:1420
 TH2.cxx:1421
 TH2.cxx:1422
 TH2.cxx:1423
 TH2.cxx:1424
 TH2.cxx:1425
 TH2.cxx:1426
 TH2.cxx:1427
 TH2.cxx:1428
 TH2.cxx:1429
 TH2.cxx:1430
 TH2.cxx:1431
 TH2.cxx:1432
 TH2.cxx:1433
 TH2.cxx:1434
 TH2.cxx:1435
 TH2.cxx:1436
 TH2.cxx:1437
 TH2.cxx:1438
 TH2.cxx:1439
 TH2.cxx:1440
 TH2.cxx:1441
 TH2.cxx:1442
 TH2.cxx:1443
 TH2.cxx:1444
 TH2.cxx:1445
 TH2.cxx:1446
 TH2.cxx:1447
 TH2.cxx:1448
 TH2.cxx:1449
 TH2.cxx:1450
 TH2.cxx:1451
 TH2.cxx:1452
 TH2.cxx:1453
 TH2.cxx:1454
 TH2.cxx:1455
 TH2.cxx:1456
 TH2.cxx:1457
 TH2.cxx:1458
 TH2.cxx:1459
 TH2.cxx:1460
 TH2.cxx:1461
 TH2.cxx:1462
 TH2.cxx:1463
 TH2.cxx:1464
 TH2.cxx:1465
 TH2.cxx:1466
 TH2.cxx:1467
 TH2.cxx:1468
 TH2.cxx:1469
 TH2.cxx:1470
 TH2.cxx:1471
 TH2.cxx:1472
 TH2.cxx:1473
 TH2.cxx:1474
 TH2.cxx:1475
 TH2.cxx:1476
 TH2.cxx:1477
 TH2.cxx:1478
 TH2.cxx:1479
 TH2.cxx:1480
 TH2.cxx:1481
 TH2.cxx:1482
 TH2.cxx:1483
 TH2.cxx:1484
 TH2.cxx:1485
 TH2.cxx:1486
 TH2.cxx:1487
 TH2.cxx:1488
 TH2.cxx:1489
 TH2.cxx:1490
 TH2.cxx:1491
 TH2.cxx:1492
 TH2.cxx:1493
 TH2.cxx:1494
 TH2.cxx:1495
 TH2.cxx:1496
 TH2.cxx:1497
 TH2.cxx:1498
 TH2.cxx:1499
 TH2.cxx:1500
 TH2.cxx:1501
 TH2.cxx:1502
 TH2.cxx:1503
 TH2.cxx:1504
 TH2.cxx:1505
 TH2.cxx:1506
 TH2.cxx:1507
 TH2.cxx:1508
 TH2.cxx:1509
 TH2.cxx:1510
 TH2.cxx:1511
 TH2.cxx:1512
 TH2.cxx:1513
 TH2.cxx:1514
 TH2.cxx:1515
 TH2.cxx:1516
 TH2.cxx:1517
 TH2.cxx:1518
 TH2.cxx:1519
 TH2.cxx:1520
 TH2.cxx:1521
 TH2.cxx:1522
 TH2.cxx:1523
 TH2.cxx:1524
 TH2.cxx:1525
 TH2.cxx:1526
 TH2.cxx:1527
 TH2.cxx:1528
 TH2.cxx:1529
 TH2.cxx:1530
 TH2.cxx:1531
 TH2.cxx:1532
 TH2.cxx:1533
 TH2.cxx:1534
 TH2.cxx:1535
 TH2.cxx:1536
 TH2.cxx:1537
 TH2.cxx:1538
 TH2.cxx:1539
 TH2.cxx:1540
 TH2.cxx:1541
 TH2.cxx:1542
 TH2.cxx:1543
 TH2.cxx:1544
 TH2.cxx:1545
 TH2.cxx:1546
 TH2.cxx:1547
 TH2.cxx:1548
 TH2.cxx:1549
 TH2.cxx:1550
 TH2.cxx:1551
 TH2.cxx:1552
 TH2.cxx:1553
 TH2.cxx:1554
 TH2.cxx:1555
 TH2.cxx:1556
 TH2.cxx:1557
 TH2.cxx:1558
 TH2.cxx:1559
 TH2.cxx:1560
 TH2.cxx:1561
 TH2.cxx:1562
 TH2.cxx:1563
 TH2.cxx:1564
 TH2.cxx:1565
 TH2.cxx:1566
 TH2.cxx:1567
 TH2.cxx:1568
 TH2.cxx:1569
 TH2.cxx:1570
 TH2.cxx:1571
 TH2.cxx:1572
 TH2.cxx:1573
 TH2.cxx:1574
 TH2.cxx:1575
 TH2.cxx:1576
 TH2.cxx:1577
 TH2.cxx:1578
 TH2.cxx:1579
 TH2.cxx:1580
 TH2.cxx:1581
 TH2.cxx:1582
 TH2.cxx:1583
 TH2.cxx:1584
 TH2.cxx:1585
 TH2.cxx:1586
 TH2.cxx:1587
 TH2.cxx:1588
 TH2.cxx:1589
 TH2.cxx:1590
 TH2.cxx:1591
 TH2.cxx:1592
 TH2.cxx:1593
 TH2.cxx:1594
 TH2.cxx:1595
 TH2.cxx:1596
 TH2.cxx:1597
 TH2.cxx:1598
 TH2.cxx:1599
 TH2.cxx:1600
 TH2.cxx:1601
 TH2.cxx:1602
 TH2.cxx:1603
 TH2.cxx:1604
 TH2.cxx:1605
 TH2.cxx:1606
 TH2.cxx:1607
 TH2.cxx:1608
 TH2.cxx:1609
 TH2.cxx:1610
 TH2.cxx:1611
 TH2.cxx:1612
 TH2.cxx:1613
 TH2.cxx:1614
 TH2.cxx:1615
 TH2.cxx:1616
 TH2.cxx:1617
 TH2.cxx:1618
 TH2.cxx:1619
 TH2.cxx:1620
 TH2.cxx:1621
 TH2.cxx:1622
 TH2.cxx:1623
 TH2.cxx:1624
 TH2.cxx:1625
 TH2.cxx:1626
 TH2.cxx:1627
 TH2.cxx:1628
 TH2.cxx:1629
 TH2.cxx:1630
 TH2.cxx:1631
 TH2.cxx:1632
 TH2.cxx:1633
 TH2.cxx:1634
 TH2.cxx:1635
 TH2.cxx:1636
 TH2.cxx:1637
 TH2.cxx:1638
 TH2.cxx:1639
 TH2.cxx:1640
 TH2.cxx:1641
 TH2.cxx:1642
 TH2.cxx:1643
 TH2.cxx:1644
 TH2.cxx:1645
 TH2.cxx:1646
 TH2.cxx:1647
 TH2.cxx:1648
 TH2.cxx:1649
 TH2.cxx:1650
 TH2.cxx:1651
 TH2.cxx:1652
 TH2.cxx:1653
 TH2.cxx:1654
 TH2.cxx:1655
 TH2.cxx:1656
 TH2.cxx:1657
 TH2.cxx:1658
 TH2.cxx:1659
 TH2.cxx:1660
 TH2.cxx:1661
 TH2.cxx:1662
 TH2.cxx:1663
 TH2.cxx:1664
 TH2.cxx:1665
 TH2.cxx:1666
 TH2.cxx:1667
 TH2.cxx:1668
 TH2.cxx:1669
 TH2.cxx:1670
 TH2.cxx:1671
 TH2.cxx:1672
 TH2.cxx:1673
 TH2.cxx:1674
 TH2.cxx:1675
 TH2.cxx:1676
 TH2.cxx:1677
 TH2.cxx:1678
 TH2.cxx:1679
 TH2.cxx:1680
 TH2.cxx:1681
 TH2.cxx:1682
 TH2.cxx:1683
 TH2.cxx:1684
 TH2.cxx:1685
 TH2.cxx:1686
 TH2.cxx:1687
 TH2.cxx:1688
 TH2.cxx:1689
 TH2.cxx:1690
 TH2.cxx:1691
 TH2.cxx:1692
 TH2.cxx:1693
 TH2.cxx:1694
 TH2.cxx:1695
 TH2.cxx:1696
 TH2.cxx:1697
 TH2.cxx:1698
 TH2.cxx:1699
 TH2.cxx:1700
 TH2.cxx:1701
 TH2.cxx:1702
 TH2.cxx:1703
 TH2.cxx:1704
 TH2.cxx:1705
 TH2.cxx:1706
 TH2.cxx:1707
 TH2.cxx:1708
 TH2.cxx:1709
 TH2.cxx:1710
 TH2.cxx:1711
 TH2.cxx:1712
 TH2.cxx:1713
 TH2.cxx:1714
 TH2.cxx:1715
 TH2.cxx:1716
 TH2.cxx:1717
 TH2.cxx:1718
 TH2.cxx:1719
 TH2.cxx:1720
 TH2.cxx:1721
 TH2.cxx:1722
 TH2.cxx:1723
 TH2.cxx:1724
 TH2.cxx:1725
 TH2.cxx:1726
 TH2.cxx:1727
 TH2.cxx:1728
 TH2.cxx:1729
 TH2.cxx:1730
 TH2.cxx:1731
 TH2.cxx:1732
 TH2.cxx:1733
 TH2.cxx:1734
 TH2.cxx:1735
 TH2.cxx:1736
 TH2.cxx:1737
 TH2.cxx:1738
 TH2.cxx:1739
 TH2.cxx:1740
 TH2.cxx:1741
 TH2.cxx:1742
 TH2.cxx:1743
 TH2.cxx:1744
 TH2.cxx:1745
 TH2.cxx:1746
 TH2.cxx:1747
 TH2.cxx:1748
 TH2.cxx:1749
 TH2.cxx:1750
 TH2.cxx:1751
 TH2.cxx:1752
 TH2.cxx:1753
 TH2.cxx:1754
 TH2.cxx:1755
 TH2.cxx:1756
 TH2.cxx:1757
 TH2.cxx:1758
 TH2.cxx:1759
 TH2.cxx:1760
 TH2.cxx:1761
 TH2.cxx:1762
 TH2.cxx:1763
 TH2.cxx:1764
 TH2.cxx:1765
 TH2.cxx:1766
 TH2.cxx:1767
 TH2.cxx:1768
 TH2.cxx:1769
 TH2.cxx:1770
 TH2.cxx:1771
 TH2.cxx:1772
 TH2.cxx:1773
 TH2.cxx:1774
 TH2.cxx:1775
 TH2.cxx:1776
 TH2.cxx:1777
 TH2.cxx:1778
 TH2.cxx:1779
 TH2.cxx:1780
 TH2.cxx:1781
 TH2.cxx:1782
 TH2.cxx:1783
 TH2.cxx:1784
 TH2.cxx:1785
 TH2.cxx:1786
 TH2.cxx:1787
 TH2.cxx:1788
 TH2.cxx:1789
 TH2.cxx:1790
 TH2.cxx:1791
 TH2.cxx:1792
 TH2.cxx:1793
 TH2.cxx:1794
 TH2.cxx:1795
 TH2.cxx:1796
 TH2.cxx:1797
 TH2.cxx:1798
 TH2.cxx:1799
 TH2.cxx:1800
 TH2.cxx:1801
 TH2.cxx:1802
 TH2.cxx:1803
 TH2.cxx:1804
 TH2.cxx:1805
 TH2.cxx:1806
 TH2.cxx:1807
 TH2.cxx:1808
 TH2.cxx:1809
 TH2.cxx:1810
 TH2.cxx:1811
 TH2.cxx:1812
 TH2.cxx:1813
 TH2.cxx:1814
 TH2.cxx:1815
 TH2.cxx:1816
 TH2.cxx:1817
 TH2.cxx:1818
 TH2.cxx:1819
 TH2.cxx:1820
 TH2.cxx:1821
 TH2.cxx:1822
 TH2.cxx:1823
 TH2.cxx:1824
 TH2.cxx:1825
 TH2.cxx:1826
 TH2.cxx:1827
 TH2.cxx:1828
 TH2.cxx:1829
 TH2.cxx:1830
 TH2.cxx:1831
 TH2.cxx:1832
 TH2.cxx:1833
 TH2.cxx:1834
 TH2.cxx:1835
 TH2.cxx:1836
 TH2.cxx:1837
 TH2.cxx:1838
 TH2.cxx:1839
 TH2.cxx:1840
 TH2.cxx:1841
 TH2.cxx:1842
 TH2.cxx:1843
 TH2.cxx:1844
 TH2.cxx:1845
 TH2.cxx:1846
 TH2.cxx:1847
 TH2.cxx:1848
 TH2.cxx:1849
 TH2.cxx:1850
 TH2.cxx:1851
 TH2.cxx:1852
 TH2.cxx:1853
 TH2.cxx:1854
 TH2.cxx:1855
 TH2.cxx:1856
 TH2.cxx:1857
 TH2.cxx:1858
 TH2.cxx:1859
 TH2.cxx:1860
 TH2.cxx:1861
 TH2.cxx:1862
 TH2.cxx:1863
 TH2.cxx:1864
 TH2.cxx:1865
 TH2.cxx:1866
 TH2.cxx:1867
 TH2.cxx:1868
 TH2.cxx:1869
 TH2.cxx:1870
 TH2.cxx:1871
 TH2.cxx:1872
 TH2.cxx:1873
 TH2.cxx:1874
 TH2.cxx:1875
 TH2.cxx:1876
 TH2.cxx:1877
 TH2.cxx:1878
 TH2.cxx:1879
 TH2.cxx:1880
 TH2.cxx:1881
 TH2.cxx:1882
 TH2.cxx:1883
 TH2.cxx:1884
 TH2.cxx:1885
 TH2.cxx:1886
 TH2.cxx:1887
 TH2.cxx:1888
 TH2.cxx:1889
 TH2.cxx:1890
 TH2.cxx:1891
 TH2.cxx:1892
 TH2.cxx:1893
 TH2.cxx:1894
 TH2.cxx:1895
 TH2.cxx:1896
 TH2.cxx:1897
 TH2.cxx:1898
 TH2.cxx:1899
 TH2.cxx:1900
 TH2.cxx:1901
 TH2.cxx:1902
 TH2.cxx:1903
 TH2.cxx:1904
 TH2.cxx:1905
 TH2.cxx:1906
 TH2.cxx:1907
 TH2.cxx:1908
 TH2.cxx:1909
 TH2.cxx:1910
 TH2.cxx:1911
 TH2.cxx:1912
 TH2.cxx:1913
 TH2.cxx:1914
 TH2.cxx:1915
 TH2.cxx:1916
 TH2.cxx:1917
 TH2.cxx:1918
 TH2.cxx:1919
 TH2.cxx:1920
 TH2.cxx:1921
 TH2.cxx:1922
 TH2.cxx:1923
 TH2.cxx:1924
 TH2.cxx:1925
 TH2.cxx:1926
 TH2.cxx:1927
 TH2.cxx:1928
 TH2.cxx:1929
 TH2.cxx:1930
 TH2.cxx:1931
 TH2.cxx:1932
 TH2.cxx:1933
 TH2.cxx:1934
 TH2.cxx:1935
 TH2.cxx:1936
 TH2.cxx:1937
 TH2.cxx:1938
 TH2.cxx:1939
 TH2.cxx:1940
 TH2.cxx:1941
 TH2.cxx:1942
 TH2.cxx:1943
 TH2.cxx:1944
 TH2.cxx:1945
 TH2.cxx:1946
 TH2.cxx:1947
 TH2.cxx:1948
 TH2.cxx:1949
 TH2.cxx:1950
 TH2.cxx:1951
 TH2.cxx:1952
 TH2.cxx:1953
 TH2.cxx:1954
 TH2.cxx:1955
 TH2.cxx:1956
 TH2.cxx:1957
 TH2.cxx:1958
 TH2.cxx:1959
 TH2.cxx:1960
 TH2.cxx:1961
 TH2.cxx:1962
 TH2.cxx:1963
 TH2.cxx:1964
 TH2.cxx:1965
 TH2.cxx:1966
 TH2.cxx:1967
 TH2.cxx:1968
 TH2.cxx:1969
 TH2.cxx:1970
 TH2.cxx:1971
 TH2.cxx:1972
 TH2.cxx:1973
 TH2.cxx:1974
 TH2.cxx:1975
 TH2.cxx:1976
 TH2.cxx:1977
 TH2.cxx:1978
 TH2.cxx:1979
 TH2.cxx:1980
 TH2.cxx:1981
 TH2.cxx:1982
 TH2.cxx:1983
 TH2.cxx:1984
 TH2.cxx:1985
 TH2.cxx:1986
 TH2.cxx:1987
 TH2.cxx:1988
 TH2.cxx:1989
 TH2.cxx:1990
 TH2.cxx:1991
 TH2.cxx:1992
 TH2.cxx:1993
 TH2.cxx:1994
 TH2.cxx:1995
 TH2.cxx:1996
 TH2.cxx:1997
 TH2.cxx:1998
 TH2.cxx:1999
 TH2.cxx:2000
 TH2.cxx:2001
 TH2.cxx:2002
 TH2.cxx:2003
 TH2.cxx:2004
 TH2.cxx:2005
 TH2.cxx:2006
 TH2.cxx:2007
 TH2.cxx:2008
 TH2.cxx:2009
 TH2.cxx:2010
 TH2.cxx:2011
 TH2.cxx:2012
 TH2.cxx:2013
 TH2.cxx:2014
 TH2.cxx:2015
 TH2.cxx:2016
 TH2.cxx:2017
 TH2.cxx:2018
 TH2.cxx:2019
 TH2.cxx:2020
 TH2.cxx:2021
 TH2.cxx:2022
 TH2.cxx:2023
 TH2.cxx:2024
 TH2.cxx:2025
 TH2.cxx:2026
 TH2.cxx:2027
 TH2.cxx:2028
 TH2.cxx:2029
 TH2.cxx:2030
 TH2.cxx:2031
 TH2.cxx:2032
 TH2.cxx:2033
 TH2.cxx:2034
 TH2.cxx:2035
 TH2.cxx:2036
 TH2.cxx:2037
 TH2.cxx:2038
 TH2.cxx:2039
 TH2.cxx:2040
 TH2.cxx:2041
 TH2.cxx:2042
 TH2.cxx:2043
 TH2.cxx:2044
 TH2.cxx:2045
 TH2.cxx:2046
 TH2.cxx:2047
 TH2.cxx:2048
 TH2.cxx:2049
 TH2.cxx:2050
 TH2.cxx:2051
 TH2.cxx:2052
 TH2.cxx:2053
 TH2.cxx:2054
 TH2.cxx:2055
 TH2.cxx:2056
 TH2.cxx:2057
 TH2.cxx:2058
 TH2.cxx:2059
 TH2.cxx:2060
 TH2.cxx:2061
 TH2.cxx:2062
 TH2.cxx:2063
 TH2.cxx:2064
 TH2.cxx:2065
 TH2.cxx:2066
 TH2.cxx:2067
 TH2.cxx:2068
 TH2.cxx:2069
 TH2.cxx:2070
 TH2.cxx:2071
 TH2.cxx:2072
 TH2.cxx:2073
 TH2.cxx:2074
 TH2.cxx:2075
 TH2.cxx:2076
 TH2.cxx:2077
 TH2.cxx:2078
 TH2.cxx:2079
 TH2.cxx:2080
 TH2.cxx:2081
 TH2.cxx:2082
 TH2.cxx:2083
 TH2.cxx:2084
 TH2.cxx:2085
 TH2.cxx:2086
 TH2.cxx:2087
 TH2.cxx:2088
 TH2.cxx:2089
 TH2.cxx:2090
 TH2.cxx:2091
 TH2.cxx:2092
 TH2.cxx:2093
 TH2.cxx:2094
 TH2.cxx:2095
 TH2.cxx:2096
 TH2.cxx:2097
 TH2.cxx:2098
 TH2.cxx:2099
 TH2.cxx:2100
 TH2.cxx:2101
 TH2.cxx:2102
 TH2.cxx:2103
 TH2.cxx:2104
 TH2.cxx:2105
 TH2.cxx:2106
 TH2.cxx:2107
 TH2.cxx:2108
 TH2.cxx:2109
 TH2.cxx:2110
 TH2.cxx:2111
 TH2.cxx:2112
 TH2.cxx:2113
 TH2.cxx:2114
 TH2.cxx:2115
 TH2.cxx:2116
 TH2.cxx:2117
 TH2.cxx:2118
 TH2.cxx:2119
 TH2.cxx:2120
 TH2.cxx:2121
 TH2.cxx:2122
 TH2.cxx:2123
 TH2.cxx:2124
 TH2.cxx:2125
 TH2.cxx:2126
 TH2.cxx:2127
 TH2.cxx:2128
 TH2.cxx:2129
 TH2.cxx:2130
 TH2.cxx:2131
 TH2.cxx:2132
 TH2.cxx:2133
 TH2.cxx:2134
 TH2.cxx:2135
 TH2.cxx:2136
 TH2.cxx:2137
 TH2.cxx:2138
 TH2.cxx:2139
 TH2.cxx:2140
 TH2.cxx:2141
 TH2.cxx:2142
 TH2.cxx:2143
 TH2.cxx:2144
 TH2.cxx:2145
 TH2.cxx:2146
 TH2.cxx:2147
 TH2.cxx:2148
 TH2.cxx:2149
 TH2.cxx:2150
 TH2.cxx:2151
 TH2.cxx:2152
 TH2.cxx:2153
 TH2.cxx:2154
 TH2.cxx:2155
 TH2.cxx:2156
 TH2.cxx:2157
 TH2.cxx:2158
 TH2.cxx:2159
 TH2.cxx:2160
 TH2.cxx:2161
 TH2.cxx:2162
 TH2.cxx:2163
 TH2.cxx:2164
 TH2.cxx:2165
 TH2.cxx:2166
 TH2.cxx:2167
 TH2.cxx:2168
 TH2.cxx:2169
 TH2.cxx:2170
 TH2.cxx:2171
 TH2.cxx:2172
 TH2.cxx:2173
 TH2.cxx:2174
 TH2.cxx:2175
 TH2.cxx:2176
 TH2.cxx:2177
 TH2.cxx:2178
 TH2.cxx:2179
 TH2.cxx:2180
 TH2.cxx:2181
 TH2.cxx:2182
 TH2.cxx:2183
 TH2.cxx:2184
 TH2.cxx:2185
 TH2.cxx:2186
 TH2.cxx:2187
 TH2.cxx:2188
 TH2.cxx:2189
 TH2.cxx:2190
 TH2.cxx:2191
 TH2.cxx:2192
 TH2.cxx:2193
 TH2.cxx:2194
 TH2.cxx:2195
 TH2.cxx:2196
 TH2.cxx:2197
 TH2.cxx:2198
 TH2.cxx:2199
 TH2.cxx:2200
 TH2.cxx:2201
 TH2.cxx:2202
 TH2.cxx:2203
 TH2.cxx:2204
 TH2.cxx:2205
 TH2.cxx:2206
 TH2.cxx:2207
 TH2.cxx:2208
 TH2.cxx:2209
 TH2.cxx:2210
 TH2.cxx:2211
 TH2.cxx:2212
 TH2.cxx:2213
 TH2.cxx:2214
 TH2.cxx:2215
 TH2.cxx:2216
 TH2.cxx:2217
 TH2.cxx:2218
 TH2.cxx:2219
 TH2.cxx:2220
 TH2.cxx:2221
 TH2.cxx:2222
 TH2.cxx:2223
 TH2.cxx:2224
 TH2.cxx:2225
 TH2.cxx:2226
 TH2.cxx:2227
 TH2.cxx:2228
 TH2.cxx:2229
 TH2.cxx:2230
 TH2.cxx:2231
 TH2.cxx:2232
 TH2.cxx:2233
 TH2.cxx:2234
 TH2.cxx:2235
 TH2.cxx:2236
 TH2.cxx:2237
 TH2.cxx:2238
 TH2.cxx:2239
 TH2.cxx:2240
 TH2.cxx:2241
 TH2.cxx:2242
 TH2.cxx:2243
 TH2.cxx:2244
 TH2.cxx:2245
 TH2.cxx:2246
 TH2.cxx:2247
 TH2.cxx:2248
 TH2.cxx:2249
 TH2.cxx:2250
 TH2.cxx:2251
 TH2.cxx:2252
 TH2.cxx:2253
 TH2.cxx:2254
 TH2.cxx:2255
 TH2.cxx:2256
 TH2.cxx:2257
 TH2.cxx:2258
 TH2.cxx:2259
 TH2.cxx:2260
 TH2.cxx:2261
 TH2.cxx:2262
 TH2.cxx:2263
 TH2.cxx:2264
 TH2.cxx:2265
 TH2.cxx:2266
 TH2.cxx:2267
 TH2.cxx:2268
 TH2.cxx:2269
 TH2.cxx:2270
 TH2.cxx:2271
 TH2.cxx:2272
 TH2.cxx:2273
 TH2.cxx:2274
 TH2.cxx:2275
 TH2.cxx:2276
 TH2.cxx:2277
 TH2.cxx:2278
 TH2.cxx:2279
 TH2.cxx:2280
 TH2.cxx:2281
 TH2.cxx:2282
 TH2.cxx:2283
 TH2.cxx:2284
 TH2.cxx:2285
 TH2.cxx:2286
 TH2.cxx:2287
 TH2.cxx:2288
 TH2.cxx:2289
 TH2.cxx:2290
 TH2.cxx:2291
 TH2.cxx:2292
 TH2.cxx:2293
 TH2.cxx:2294
 TH2.cxx:2295
 TH2.cxx:2296
 TH2.cxx:2297
 TH2.cxx:2298
 TH2.cxx:2299
 TH2.cxx:2300
 TH2.cxx:2301
 TH2.cxx:2302
 TH2.cxx:2303
 TH2.cxx:2304
 TH2.cxx:2305
 TH2.cxx:2306
 TH2.cxx:2307
 TH2.cxx:2308
 TH2.cxx:2309
 TH2.cxx:2310
 TH2.cxx:2311
 TH2.cxx:2312
 TH2.cxx:2313
 TH2.cxx:2314
 TH2.cxx:2315
 TH2.cxx:2316
 TH2.cxx:2317
 TH2.cxx:2318
 TH2.cxx:2319
 TH2.cxx:2320
 TH2.cxx:2321
 TH2.cxx:2322
 TH2.cxx:2323
 TH2.cxx:2324
 TH2.cxx:2325
 TH2.cxx:2326
 TH2.cxx:2327
 TH2.cxx:2328
 TH2.cxx:2329
 TH2.cxx:2330
 TH2.cxx:2331
 TH2.cxx:2332
 TH2.cxx:2333
 TH2.cxx:2334
 TH2.cxx:2335
 TH2.cxx:2336
 TH2.cxx:2337
 TH2.cxx:2338
 TH2.cxx:2339
 TH2.cxx:2340
 TH2.cxx:2341
 TH2.cxx:2342
 TH2.cxx:2343
 TH2.cxx:2344
 TH2.cxx:2345
 TH2.cxx:2346
 TH2.cxx:2347
 TH2.cxx:2348
 TH2.cxx:2349
 TH2.cxx:2350
 TH2.cxx:2351
 TH2.cxx:2352
 TH2.cxx:2353
 TH2.cxx:2354
 TH2.cxx:2355
 TH2.cxx:2356
 TH2.cxx:2357
 TH2.cxx:2358
 TH2.cxx:2359
 TH2.cxx:2360
 TH2.cxx:2361
 TH2.cxx:2362
 TH2.cxx:2363
 TH2.cxx:2364
 TH2.cxx:2365
 TH2.cxx:2366
 TH2.cxx:2367
 TH2.cxx:2368
 TH2.cxx:2369
 TH2.cxx:2370
 TH2.cxx:2371
 TH2.cxx:2372
 TH2.cxx:2373
 TH2.cxx:2374
 TH2.cxx:2375
 TH2.cxx:2376
 TH2.cxx:2377
 TH2.cxx:2378
 TH2.cxx:2379
 TH2.cxx:2380
 TH2.cxx:2381
 TH2.cxx:2382
 TH2.cxx:2383
 TH2.cxx:2384
 TH2.cxx:2385
 TH2.cxx:2386
 TH2.cxx:2387
 TH2.cxx:2388
 TH2.cxx:2389
 TH2.cxx:2390
 TH2.cxx:2391
 TH2.cxx:2392
 TH2.cxx:2393
 TH2.cxx:2394
 TH2.cxx:2395
 TH2.cxx:2396
 TH2.cxx:2397
 TH2.cxx:2398
 TH2.cxx:2399
 TH2.cxx:2400
 TH2.cxx:2401
 TH2.cxx:2402
 TH2.cxx:2403
 TH2.cxx:2404
 TH2.cxx:2405
 TH2.cxx:2406
 TH2.cxx:2407
 TH2.cxx:2408
 TH2.cxx:2409
 TH2.cxx:2410
 TH2.cxx:2411
 TH2.cxx:2412
 TH2.cxx:2413
 TH2.cxx:2414
 TH2.cxx:2415
 TH2.cxx:2416
 TH2.cxx:2417
 TH2.cxx:2418
 TH2.cxx:2419
 TH2.cxx:2420
 TH2.cxx:2421
 TH2.cxx:2422
 TH2.cxx:2423
 TH2.cxx:2424
 TH2.cxx:2425
 TH2.cxx:2426
 TH2.cxx:2427
 TH2.cxx:2428
 TH2.cxx:2429
 TH2.cxx:2430
 TH2.cxx:2431
 TH2.cxx:2432
 TH2.cxx:2433
 TH2.cxx:2434
 TH2.cxx:2435
 TH2.cxx:2436
 TH2.cxx:2437
 TH2.cxx:2438
 TH2.cxx:2439
 TH2.cxx:2440
 TH2.cxx:2441
 TH2.cxx:2442
 TH2.cxx:2443
 TH2.cxx:2444
 TH2.cxx:2445
 TH2.cxx:2446
 TH2.cxx:2447
 TH2.cxx:2448
 TH2.cxx:2449
 TH2.cxx:2450
 TH2.cxx:2451
 TH2.cxx:2452
 TH2.cxx:2453
 TH2.cxx:2454
 TH2.cxx:2455
 TH2.cxx:2456
 TH2.cxx:2457
 TH2.cxx:2458
 TH2.cxx:2459
 TH2.cxx:2460
 TH2.cxx:2461
 TH2.cxx:2462
 TH2.cxx:2463
 TH2.cxx:2464
 TH2.cxx:2465
 TH2.cxx:2466
 TH2.cxx:2467
 TH2.cxx:2468
 TH2.cxx:2469
 TH2.cxx:2470
 TH2.cxx:2471
 TH2.cxx:2472
 TH2.cxx:2473
 TH2.cxx:2474
 TH2.cxx:2475
 TH2.cxx:2476
 TH2.cxx:2477
 TH2.cxx:2478
 TH2.cxx:2479
 TH2.cxx:2480
 TH2.cxx:2481
 TH2.cxx:2482
 TH2.cxx:2483
 TH2.cxx:2484
 TH2.cxx:2485
 TH2.cxx:2486
 TH2.cxx:2487
 TH2.cxx:2488
 TH2.cxx:2489
 TH2.cxx:2490
 TH2.cxx:2491
 TH2.cxx:2492
 TH2.cxx:2493
 TH2.cxx:2494
 TH2.cxx:2495
 TH2.cxx:2496
 TH2.cxx:2497
 TH2.cxx:2498
 TH2.cxx:2499
 TH2.cxx:2500
 TH2.cxx:2501
 TH2.cxx:2502
 TH2.cxx:2503
 TH2.cxx:2504
 TH2.cxx:2505
 TH2.cxx:2506
 TH2.cxx:2507
 TH2.cxx:2508
 TH2.cxx:2509
 TH2.cxx:2510
 TH2.cxx:2511
 TH2.cxx:2512
 TH2.cxx:2513
 TH2.cxx:2514
 TH2.cxx:2515
 TH2.cxx:2516
 TH2.cxx:2517
 TH2.cxx:2518
 TH2.cxx:2519
 TH2.cxx:2520
 TH2.cxx:2521
 TH2.cxx:2522
 TH2.cxx:2523
 TH2.cxx:2524
 TH2.cxx:2525
 TH2.cxx:2526
 TH2.cxx:2527
 TH2.cxx:2528
 TH2.cxx:2529
 TH2.cxx:2530
 TH2.cxx:2531
 TH2.cxx:2532
 TH2.cxx:2533
 TH2.cxx:2534
 TH2.cxx:2535
 TH2.cxx:2536
 TH2.cxx:2537
 TH2.cxx:2538
 TH2.cxx:2539
 TH2.cxx:2540
 TH2.cxx:2541
 TH2.cxx:2542
 TH2.cxx:2543
 TH2.cxx:2544
 TH2.cxx:2545
 TH2.cxx:2546
 TH2.cxx:2547
 TH2.cxx:2548
 TH2.cxx:2549
 TH2.cxx:2550
 TH2.cxx:2551
 TH2.cxx:2552
 TH2.cxx:2553
 TH2.cxx:2554
 TH2.cxx:2555
 TH2.cxx:2556
 TH2.cxx:2557
 TH2.cxx:2558
 TH2.cxx:2559
 TH2.cxx:2560
 TH2.cxx:2561
 TH2.cxx:2562
 TH2.cxx:2563
 TH2.cxx:2564
 TH2.cxx:2565
 TH2.cxx:2566
 TH2.cxx:2567
 TH2.cxx:2568
 TH2.cxx:2569
 TH2.cxx:2570
 TH2.cxx:2571
 TH2.cxx:2572
 TH2.cxx:2573
 TH2.cxx:2574
 TH2.cxx:2575
 TH2.cxx:2576
 TH2.cxx:2577
 TH2.cxx:2578
 TH2.cxx:2579
 TH2.cxx:2580
 TH2.cxx:2581
 TH2.cxx:2582
 TH2.cxx:2583
 TH2.cxx:2584
 TH2.cxx:2585
 TH2.cxx:2586
 TH2.cxx:2587
 TH2.cxx:2588
 TH2.cxx:2589
 TH2.cxx:2590
 TH2.cxx:2591
 TH2.cxx:2592
 TH2.cxx:2593
 TH2.cxx:2594
 TH2.cxx:2595
 TH2.cxx:2596
 TH2.cxx:2597
 TH2.cxx:2598
 TH2.cxx:2599
 TH2.cxx:2600
 TH2.cxx:2601
 TH2.cxx:2602
 TH2.cxx:2603
 TH2.cxx:2604
 TH2.cxx:2605
 TH2.cxx:2606
 TH2.cxx:2607
 TH2.cxx:2608
 TH2.cxx:2609
 TH2.cxx:2610
 TH2.cxx:2611
 TH2.cxx:2612
 TH2.cxx:2613
 TH2.cxx:2614
 TH2.cxx:2615
 TH2.cxx:2616
 TH2.cxx:2617
 TH2.cxx:2618
 TH2.cxx:2619
 TH2.cxx:2620
 TH2.cxx:2621
 TH2.cxx:2622
 TH2.cxx:2623
 TH2.cxx:2624
 TH2.cxx:2625
 TH2.cxx:2626
 TH2.cxx:2627
 TH2.cxx:2628
 TH2.cxx:2629
 TH2.cxx:2630
 TH2.cxx:2631
 TH2.cxx:2632
 TH2.cxx:2633
 TH2.cxx:2634
 TH2.cxx:2635
 TH2.cxx:2636
 TH2.cxx:2637
 TH2.cxx:2638
 TH2.cxx:2639
 TH2.cxx:2640
 TH2.cxx:2641
 TH2.cxx:2642
 TH2.cxx:2643
 TH2.cxx:2644
 TH2.cxx:2645
 TH2.cxx:2646
 TH2.cxx:2647
 TH2.cxx:2648
 TH2.cxx:2649
 TH2.cxx:2650
 TH2.cxx:2651
 TH2.cxx:2652
 TH2.cxx:2653
 TH2.cxx:2654
 TH2.cxx:2655
 TH2.cxx:2656
 TH2.cxx:2657
 TH2.cxx:2658
 TH2.cxx:2659
 TH2.cxx:2660
 TH2.cxx:2661
 TH2.cxx:2662
 TH2.cxx:2663
 TH2.cxx:2664
 TH2.cxx:2665
 TH2.cxx:2666
 TH2.cxx:2667
 TH2.cxx:2668
 TH2.cxx:2669
 TH2.cxx:2670
 TH2.cxx:2671
 TH2.cxx:2672
 TH2.cxx:2673
 TH2.cxx:2674
 TH2.cxx:2675
 TH2.cxx:2676
 TH2.cxx:2677
 TH2.cxx:2678
 TH2.cxx:2679
 TH2.cxx:2680
 TH2.cxx:2681
 TH2.cxx:2682
 TH2.cxx:2683
 TH2.cxx:2684
 TH2.cxx:2685
 TH2.cxx:2686
 TH2.cxx:2687
 TH2.cxx:2688
 TH2.cxx:2689
 TH2.cxx:2690
 TH2.cxx:2691
 TH2.cxx:2692
 TH2.cxx:2693
 TH2.cxx:2694
 TH2.cxx:2695
 TH2.cxx:2696
 TH2.cxx:2697
 TH2.cxx:2698
 TH2.cxx:2699
 TH2.cxx:2700
 TH2.cxx:2701
 TH2.cxx:2702
 TH2.cxx:2703
 TH2.cxx:2704
 TH2.cxx:2705
 TH2.cxx:2706
 TH2.cxx:2707
 TH2.cxx:2708
 TH2.cxx:2709
 TH2.cxx:2710
 TH2.cxx:2711
 TH2.cxx:2712
 TH2.cxx:2713
 TH2.cxx:2714
 TH2.cxx:2715
 TH2.cxx:2716
 TH2.cxx:2717
 TH2.cxx:2718
 TH2.cxx:2719
 TH2.cxx:2720
 TH2.cxx:2721
 TH2.cxx:2722
 TH2.cxx:2723
 TH2.cxx:2724
 TH2.cxx:2725
 TH2.cxx:2726
 TH2.cxx:2727
 TH2.cxx:2728
 TH2.cxx:2729
 TH2.cxx:2730
 TH2.cxx:2731
 TH2.cxx:2732
 TH2.cxx:2733
 TH2.cxx:2734
 TH2.cxx:2735
 TH2.cxx:2736
 TH2.cxx:2737
 TH2.cxx:2738
 TH2.cxx:2739
 TH2.cxx:2740
 TH2.cxx:2741
 TH2.cxx:2742
 TH2.cxx:2743
 TH2.cxx:2744
 TH2.cxx:2745
 TH2.cxx:2746
 TH2.cxx:2747
 TH2.cxx:2748
 TH2.cxx:2749
 TH2.cxx:2750
 TH2.cxx:2751
 TH2.cxx:2752
 TH2.cxx:2753
 TH2.cxx:2754
 TH2.cxx:2755
 TH2.cxx:2756
 TH2.cxx:2757
 TH2.cxx:2758
 TH2.cxx:2759
 TH2.cxx:2760
 TH2.cxx:2761
 TH2.cxx:2762
 TH2.cxx:2763
 TH2.cxx:2764
 TH2.cxx:2765
 TH2.cxx:2766
 TH2.cxx:2767
 TH2.cxx:2768
 TH2.cxx:2769
 TH2.cxx:2770
 TH2.cxx:2771
 TH2.cxx:2772
 TH2.cxx:2773
 TH2.cxx:2774
 TH2.cxx:2775
 TH2.cxx:2776
 TH2.cxx:2777
 TH2.cxx:2778
 TH2.cxx:2779
 TH2.cxx:2780
 TH2.cxx:2781
 TH2.cxx:2782
 TH2.cxx:2783
 TH2.cxx:2784
 TH2.cxx:2785
 TH2.cxx:2786
 TH2.cxx:2787
 TH2.cxx:2788
 TH2.cxx:2789
 TH2.cxx:2790
 TH2.cxx:2791
 TH2.cxx:2792
 TH2.cxx:2793
 TH2.cxx:2794
 TH2.cxx:2795
 TH2.cxx:2796
 TH2.cxx:2797
 TH2.cxx:2798
 TH2.cxx:2799
 TH2.cxx:2800
 TH2.cxx:2801
 TH2.cxx:2802
 TH2.cxx:2803
 TH2.cxx:2804
 TH2.cxx:2805
 TH2.cxx:2806
 TH2.cxx:2807
 TH2.cxx:2808
 TH2.cxx:2809
 TH2.cxx:2810
 TH2.cxx:2811
 TH2.cxx:2812
 TH2.cxx:2813
 TH2.cxx:2814
 TH2.cxx:2815
 TH2.cxx:2816
 TH2.cxx:2817
 TH2.cxx:2818
 TH2.cxx:2819
 TH2.cxx:2820
 TH2.cxx:2821
 TH2.cxx:2822
 TH2.cxx:2823
 TH2.cxx:2824
 TH2.cxx:2825
 TH2.cxx:2826
 TH2.cxx:2827
 TH2.cxx:2828
 TH2.cxx:2829
 TH2.cxx:2830
 TH2.cxx:2831
 TH2.cxx:2832
 TH2.cxx:2833
 TH2.cxx:2834
 TH2.cxx:2835
 TH2.cxx:2836
 TH2.cxx:2837
 TH2.cxx:2838
 TH2.cxx:2839
 TH2.cxx:2840
 TH2.cxx:2841
 TH2.cxx:2842
 TH2.cxx:2843
 TH2.cxx:2844
 TH2.cxx:2845
 TH2.cxx:2846
 TH2.cxx:2847
 TH2.cxx:2848
 TH2.cxx:2849
 TH2.cxx:2850
 TH2.cxx:2851
 TH2.cxx:2852
 TH2.cxx:2853
 TH2.cxx:2854
 TH2.cxx:2855
 TH2.cxx:2856
 TH2.cxx:2857
 TH2.cxx:2858
 TH2.cxx:2859
 TH2.cxx:2860
 TH2.cxx:2861
 TH2.cxx:2862
 TH2.cxx:2863
 TH2.cxx:2864
 TH2.cxx:2865
 TH2.cxx:2866
 TH2.cxx:2867
 TH2.cxx:2868
 TH2.cxx:2869
 TH2.cxx:2870
 TH2.cxx:2871
 TH2.cxx:2872
 TH2.cxx:2873
 TH2.cxx:2874
 TH2.cxx:2875
 TH2.cxx:2876
 TH2.cxx:2877
 TH2.cxx:2878
 TH2.cxx:2879
 TH2.cxx:2880
 TH2.cxx:2881
 TH2.cxx:2882
 TH2.cxx:2883
 TH2.cxx:2884
 TH2.cxx:2885
 TH2.cxx:2886
 TH2.cxx:2887
 TH2.cxx:2888
 TH2.cxx:2889
 TH2.cxx:2890
 TH2.cxx:2891
 TH2.cxx:2892
 TH2.cxx:2893
 TH2.cxx:2894
 TH2.cxx:2895
 TH2.cxx:2896
 TH2.cxx:2897
 TH2.cxx:2898
 TH2.cxx:2899
 TH2.cxx:2900
 TH2.cxx:2901
 TH2.cxx:2902
 TH2.cxx:2903
 TH2.cxx:2904
 TH2.cxx:2905
 TH2.cxx:2906
 TH2.cxx:2907
 TH2.cxx:2908
 TH2.cxx:2909
 TH2.cxx:2910
 TH2.cxx:2911
 TH2.cxx:2912
 TH2.cxx:2913
 TH2.cxx:2914
 TH2.cxx:2915
 TH2.cxx:2916
 TH2.cxx:2917
 TH2.cxx:2918
 TH2.cxx:2919
 TH2.cxx:2920
 TH2.cxx:2921
 TH2.cxx:2922
 TH2.cxx:2923
 TH2.cxx:2924
 TH2.cxx:2925
 TH2.cxx:2926
 TH2.cxx:2927
 TH2.cxx:2928
 TH2.cxx:2929
 TH2.cxx:2930
 TH2.cxx:2931
 TH2.cxx:2932
 TH2.cxx:2933
 TH2.cxx:2934
 TH2.cxx:2935
 TH2.cxx:2936
 TH2.cxx:2937
 TH2.cxx:2938
 TH2.cxx:2939
 TH2.cxx:2940
 TH2.cxx:2941
 TH2.cxx:2942
 TH2.cxx:2943
 TH2.cxx:2944
 TH2.cxx:2945
 TH2.cxx:2946
 TH2.cxx:2947
 TH2.cxx:2948
 TH2.cxx:2949
 TH2.cxx:2950
 TH2.cxx:2951
 TH2.cxx:2952
 TH2.cxx:2953
 TH2.cxx:2954
 TH2.cxx:2955
 TH2.cxx:2956
 TH2.cxx:2957
 TH2.cxx:2958
 TH2.cxx:2959
 TH2.cxx:2960
 TH2.cxx:2961
 TH2.cxx:2962
 TH2.cxx:2963
 TH2.cxx:2964
 TH2.cxx:2965
 TH2.cxx:2966
 TH2.cxx:2967
 TH2.cxx:2968
 TH2.cxx:2969
 TH2.cxx:2970
 TH2.cxx:2971
 TH2.cxx:2972
 TH2.cxx:2973
 TH2.cxx:2974
 TH2.cxx:2975
 TH2.cxx:2976
 TH2.cxx:2977
 TH2.cxx:2978
 TH2.cxx:2979
 TH2.cxx:2980
 TH2.cxx:2981
 TH2.cxx:2982
 TH2.cxx:2983
 TH2.cxx:2984
 TH2.cxx:2985
 TH2.cxx:2986
 TH2.cxx:2987
 TH2.cxx:2988
 TH2.cxx:2989
 TH2.cxx:2990
 TH2.cxx:2991
 TH2.cxx:2992
 TH2.cxx:2993
 TH2.cxx:2994
 TH2.cxx:2995
 TH2.cxx:2996
 TH2.cxx:2997
 TH2.cxx:2998
 TH2.cxx:2999
 TH2.cxx:3000
 TH2.cxx:3001
 TH2.cxx:3002
 TH2.cxx:3003
 TH2.cxx:3004
 TH2.cxx:3005
 TH2.cxx:3006
 TH2.cxx:3007
 TH2.cxx:3008
 TH2.cxx:3009
 TH2.cxx:3010
 TH2.cxx:3011
 TH2.cxx:3012
 TH2.cxx:3013
 TH2.cxx:3014
 TH2.cxx:3015
 TH2.cxx:3016
 TH2.cxx:3017
 TH2.cxx:3018
 TH2.cxx:3019
 TH2.cxx:3020
 TH2.cxx:3021
 TH2.cxx:3022
 TH2.cxx:3023
 TH2.cxx:3024
 TH2.cxx:3025
 TH2.cxx:3026
 TH2.cxx:3027
 TH2.cxx:3028
 TH2.cxx:3029
 TH2.cxx:3030
 TH2.cxx:3031
 TH2.cxx:3032
 TH2.cxx:3033
 TH2.cxx:3034
 TH2.cxx:3035
 TH2.cxx:3036
 TH2.cxx:3037
 TH2.cxx:3038
 TH2.cxx:3039
 TH2.cxx:3040
 TH2.cxx:3041
 TH2.cxx:3042
 TH2.cxx:3043
 TH2.cxx:3044
 TH2.cxx:3045
 TH2.cxx:3046
 TH2.cxx:3047
 TH2.cxx:3048
 TH2.cxx:3049
 TH2.cxx:3050
 TH2.cxx:3051
 TH2.cxx:3052
 TH2.cxx:3053
 TH2.cxx:3054
 TH2.cxx:3055
 TH2.cxx:3056
 TH2.cxx:3057
 TH2.cxx:3058
 TH2.cxx:3059
 TH2.cxx:3060
 TH2.cxx:3061
 TH2.cxx:3062
 TH2.cxx:3063
 TH2.cxx:3064
 TH2.cxx:3065
 TH2.cxx:3066
 TH2.cxx:3067
 TH2.cxx:3068
 TH2.cxx:3069
 TH2.cxx:3070
 TH2.cxx:3071
 TH2.cxx:3072
 TH2.cxx:3073
 TH2.cxx:3074
 TH2.cxx:3075
 TH2.cxx:3076
 TH2.cxx:3077
 TH2.cxx:3078
 TH2.cxx:3079
 TH2.cxx:3080
 TH2.cxx:3081
 TH2.cxx:3082
 TH2.cxx:3083
 TH2.cxx:3084
 TH2.cxx:3085
 TH2.cxx:3086
 TH2.cxx:3087
 TH2.cxx:3088
 TH2.cxx:3089
 TH2.cxx:3090
 TH2.cxx:3091
 TH2.cxx:3092
 TH2.cxx:3093
 TH2.cxx:3094
 TH2.cxx:3095
 TH2.cxx:3096
 TH2.cxx:3097
 TH2.cxx:3098
 TH2.cxx:3099
 TH2.cxx:3100
 TH2.cxx:3101
 TH2.cxx:3102
 TH2.cxx:3103
 TH2.cxx:3104
 TH2.cxx:3105
 TH2.cxx:3106
 TH2.cxx:3107
 TH2.cxx:3108
 TH2.cxx:3109
 TH2.cxx:3110
 TH2.cxx:3111
 TH2.cxx:3112
 TH2.cxx:3113
 TH2.cxx:3114
 TH2.cxx:3115
 TH2.cxx:3116
 TH2.cxx:3117
 TH2.cxx:3118
 TH2.cxx:3119
 TH2.cxx:3120
 TH2.cxx:3121
 TH2.cxx:3122
 TH2.cxx:3123
 TH2.cxx:3124
 TH2.cxx:3125
 TH2.cxx:3126
 TH2.cxx:3127
 TH2.cxx:3128
 TH2.cxx:3129
 TH2.cxx:3130
 TH2.cxx:3131
 TH2.cxx:3132
 TH2.cxx:3133
 TH2.cxx:3134
 TH2.cxx:3135
 TH2.cxx:3136
 TH2.cxx:3137
 TH2.cxx:3138
 TH2.cxx:3139
 TH2.cxx:3140
 TH2.cxx:3141
 TH2.cxx:3142
 TH2.cxx:3143
 TH2.cxx:3144
 TH2.cxx:3145
 TH2.cxx:3146
 TH2.cxx:3147
 TH2.cxx:3148
 TH2.cxx:3149
 TH2.cxx:3150
 TH2.cxx:3151
 TH2.cxx:3152
 TH2.cxx:3153
 TH2.cxx:3154
 TH2.cxx:3155
 TH2.cxx:3156
 TH2.cxx:3157
 TH2.cxx:3158
 TH2.cxx:3159
 TH2.cxx:3160
 TH2.cxx:3161
 TH2.cxx:3162
 TH2.cxx:3163
 TH2.cxx:3164
 TH2.cxx:3165
 TH2.cxx:3166
 TH2.cxx:3167
 TH2.cxx:3168
 TH2.cxx:3169
 TH2.cxx:3170
 TH2.cxx:3171
 TH2.cxx:3172
 TH2.cxx:3173
 TH2.cxx:3174
 TH2.cxx:3175
 TH2.cxx:3176
 TH2.cxx:3177
 TH2.cxx:3178
 TH2.cxx:3179
 TH2.cxx:3180
 TH2.cxx:3181
 TH2.cxx:3182
 TH2.cxx:3183
 TH2.cxx:3184
 TH2.cxx:3185
 TH2.cxx:3186
 TH2.cxx:3187
 TH2.cxx:3188
 TH2.cxx:3189
 TH2.cxx:3190
 TH2.cxx:3191
 TH2.cxx:3192
 TH2.cxx:3193
 TH2.cxx:3194
 TH2.cxx:3195
 TH2.cxx:3196
 TH2.cxx:3197
 TH2.cxx:3198
 TH2.cxx:3199
 TH2.cxx:3200
 TH2.cxx:3201
 TH2.cxx:3202
 TH2.cxx:3203
 TH2.cxx:3204
 TH2.cxx:3205
 TH2.cxx:3206
 TH2.cxx:3207
 TH2.cxx:3208
 TH2.cxx:3209
 TH2.cxx:3210
 TH2.cxx:3211
 TH2.cxx:3212
 TH2.cxx:3213
 TH2.cxx:3214
 TH2.cxx:3215
 TH2.cxx:3216
 TH2.cxx:3217
 TH2.cxx:3218
 TH2.cxx:3219
 TH2.cxx:3220
 TH2.cxx:3221
 TH2.cxx:3222
 TH2.cxx:3223
 TH2.cxx:3224
 TH2.cxx:3225
 TH2.cxx:3226
 TH2.cxx:3227
 TH2.cxx:3228
 TH2.cxx:3229
 TH2.cxx:3230
 TH2.cxx:3231
 TH2.cxx:3232
 TH2.cxx:3233
 TH2.cxx:3234
 TH2.cxx:3235
 TH2.cxx:3236
 TH2.cxx:3237
 TH2.cxx:3238
 TH2.cxx:3239
 TH2.cxx:3240
 TH2.cxx:3241
 TH2.cxx:3242
 TH2.cxx:3243
 TH2.cxx:3244
 TH2.cxx:3245
 TH2.cxx:3246
 TH2.cxx:3247
 TH2.cxx:3248
 TH2.cxx:3249
 TH2.cxx:3250
 TH2.cxx:3251
 TH2.cxx:3252
 TH2.cxx:3253
 TH2.cxx:3254
 TH2.cxx:3255
 TH2.cxx:3256
 TH2.cxx:3257
 TH2.cxx:3258
 TH2.cxx:3259
 TH2.cxx:3260
 TH2.cxx:3261
 TH2.cxx:3262
 TH2.cxx:3263
 TH2.cxx:3264
 TH2.cxx:3265
 TH2.cxx:3266
 TH2.cxx:3267
 TH2.cxx:3268
 TH2.cxx:3269
 TH2.cxx:3270
 TH2.cxx:3271
 TH2.cxx:3272
 TH2.cxx:3273
 TH2.cxx:3274
 TH2.cxx:3275
 TH2.cxx:3276
 TH2.cxx:3277
 TH2.cxx:3278
 TH2.cxx:3279
 TH2.cxx:3280
 TH2.cxx:3281
 TH2.cxx:3282
 TH2.cxx:3283
 TH2.cxx:3284
 TH2.cxx:3285
 TH2.cxx:3286
 TH2.cxx:3287
 TH2.cxx:3288
 TH2.cxx:3289
 TH2.cxx:3290
 TH2.cxx:3291
 TH2.cxx:3292
 TH2.cxx:3293
 TH2.cxx:3294
 TH2.cxx:3295
 TH2.cxx:3296
 TH2.cxx:3297
 TH2.cxx:3298
 TH2.cxx:3299
 TH2.cxx:3300
 TH2.cxx:3301
 TH2.cxx:3302
 TH2.cxx:3303
 TH2.cxx:3304
 TH2.cxx:3305
 TH2.cxx:3306
 TH2.cxx:3307
 TH2.cxx:3308
 TH2.cxx:3309
 TH2.cxx:3310
 TH2.cxx:3311
 TH2.cxx:3312
 TH2.cxx:3313
 TH2.cxx:3314
 TH2.cxx:3315
 TH2.cxx:3316
 TH2.cxx:3317
 TH2.cxx:3318
 TH2.cxx:3319
 TH2.cxx:3320
 TH2.cxx:3321
 TH2.cxx:3322
 TH2.cxx:3323
 TH2.cxx:3324
 TH2.cxx:3325
 TH2.cxx:3326
 TH2.cxx:3327
 TH2.cxx:3328
 TH2.cxx:3329
 TH2.cxx:3330
 TH2.cxx:3331
 TH2.cxx:3332
 TH2.cxx:3333
 TH2.cxx:3334
 TH2.cxx:3335
 TH2.cxx:3336
 TH2.cxx:3337
 TH2.cxx:3338
 TH2.cxx:3339
 TH2.cxx:3340
 TH2.cxx:3341
 TH2.cxx:3342
 TH2.cxx:3343
 TH2.cxx:3344
 TH2.cxx:3345
 TH2.cxx:3346
 TH2.cxx:3347
 TH2.cxx:3348
 TH2.cxx:3349
 TH2.cxx:3350
 TH2.cxx:3351
 TH2.cxx:3352
 TH2.cxx:3353
 TH2.cxx:3354
 TH2.cxx:3355
 TH2.cxx:3356
 TH2.cxx:3357
 TH2.cxx:3358
 TH2.cxx:3359
 TH2.cxx:3360
 TH2.cxx:3361
 TH2.cxx:3362
 TH2.cxx:3363
 TH2.cxx:3364
 TH2.cxx:3365
 TH2.cxx:3366
 TH2.cxx:3367
 TH2.cxx:3368
 TH2.cxx:3369
 TH2.cxx:3370
 TH2.cxx:3371
 TH2.cxx:3372
 TH2.cxx:3373
 TH2.cxx:3374
 TH2.cxx:3375
 TH2.cxx:3376
 TH2.cxx:3377
 TH2.cxx:3378
 TH2.cxx:3379
 TH2.cxx:3380
 TH2.cxx:3381
 TH2.cxx:3382
 TH2.cxx:3383
 TH2.cxx:3384
 TH2.cxx:3385
 TH2.cxx:3386
 TH2.cxx:3387
 TH2.cxx:3388
 TH2.cxx:3389
 TH2.cxx:3390
 TH2.cxx:3391
 TH2.cxx:3392
 TH2.cxx:3393
 TH2.cxx:3394
 TH2.cxx:3395
 TH2.cxx:3396
 TH2.cxx:3397
 TH2.cxx:3398
 TH2.cxx:3399
 TH2.cxx:3400
 TH2.cxx:3401
 TH2.cxx:3402
 TH2.cxx:3403
 TH2.cxx:3404
 TH2.cxx:3405
 TH2.cxx:3406
 TH2.cxx:3407
 TH2.cxx:3408
 TH2.cxx:3409
 TH2.cxx:3410
 TH2.cxx:3411
 TH2.cxx:3412
 TH2.cxx:3413
 TH2.cxx:3414
 TH2.cxx:3415
 TH2.cxx:3416
 TH2.cxx:3417
 TH2.cxx:3418
 TH2.cxx:3419
 TH2.cxx:3420
 TH2.cxx:3421
 TH2.cxx:3422
 TH2.cxx:3423
 TH2.cxx:3424
 TH2.cxx:3425
 TH2.cxx:3426
 TH2.cxx:3427
 TH2.cxx:3428
 TH2.cxx:3429
 TH2.cxx:3430
 TH2.cxx:3431
 TH2.cxx:3432
 TH2.cxx:3433
 TH2.cxx:3434
 TH2.cxx:3435
 TH2.cxx:3436
 TH2.cxx:3437
 TH2.cxx:3438
 TH2.cxx:3439
 TH2.cxx:3440
 TH2.cxx:3441
 TH2.cxx:3442
 TH2.cxx:3443
 TH2.cxx:3444
 TH2.cxx:3445
 TH2.cxx:3446
 TH2.cxx:3447
 TH2.cxx:3448
 TH2.cxx:3449
 TH2.cxx:3450
 TH2.cxx:3451
 TH2.cxx:3452
 TH2.cxx:3453
 TH2.cxx:3454
 TH2.cxx:3455
 TH2.cxx:3456
 TH2.cxx:3457
 TH2.cxx:3458
 TH2.cxx:3459
 TH2.cxx:3460
 TH2.cxx:3461
 TH2.cxx:3462
 TH2.cxx:3463
 TH2.cxx:3464
 TH2.cxx:3465
 TH2.cxx:3466
 TH2.cxx:3467
 TH2.cxx:3468
 TH2.cxx:3469
 TH2.cxx:3470
 TH2.cxx:3471
 TH2.cxx:3472
 TH2.cxx:3473
 TH2.cxx:3474
 TH2.cxx:3475
 TH2.cxx:3476
 TH2.cxx:3477
 TH2.cxx:3478
 TH2.cxx:3479
 TH2.cxx:3480
 TH2.cxx:3481
 TH2.cxx:3482
 TH2.cxx:3483
 TH2.cxx:3484
 TH2.cxx:3485
 TH2.cxx:3486
 TH2.cxx:3487
 TH2.cxx:3488
 TH2.cxx:3489
 TH2.cxx:3490
 TH2.cxx:3491
 TH2.cxx:3492
 TH2.cxx:3493
 TH2.cxx:3494
 TH2.cxx:3495
 TH2.cxx:3496
 TH2.cxx:3497
 TH2.cxx:3498
 TH2.cxx:3499
 TH2.cxx:3500
 TH2.cxx:3501
 TH2.cxx:3502
 TH2.cxx:3503
 TH2.cxx:3504
 TH2.cxx:3505
 TH2.cxx:3506
 TH2.cxx:3507
 TH2.cxx:3508
 TH2.cxx:3509
 TH2.cxx:3510
 TH2.cxx:3511
 TH2.cxx:3512
 TH2.cxx:3513
 TH2.cxx:3514
 TH2.cxx:3515
 TH2.cxx:3516
 TH2.cxx:3517
 TH2.cxx:3518
 TH2.cxx:3519
 TH2.cxx:3520
 TH2.cxx:3521
 TH2.cxx:3522
 TH2.cxx:3523
 TH2.cxx:3524
 TH2.cxx:3525
 TH2.cxx:3526
 TH2.cxx:3527
 TH2.cxx:3528
 TH2.cxx:3529
 TH2.cxx:3530
 TH2.cxx:3531
 TH2.cxx:3532
 TH2.cxx:3533
 TH2.cxx:3534
 TH2.cxx:3535
 TH2.cxx:3536
 TH2.cxx:3537
 TH2.cxx:3538
 TH2.cxx:3539
 TH2.cxx:3540
 TH2.cxx:3541
 TH2.cxx:3542
 TH2.cxx:3543
 TH2.cxx:3544
 TH2.cxx:3545
 TH2.cxx:3546
 TH2.cxx:3547
 TH2.cxx:3548
 TH2.cxx:3549
 TH2.cxx:3550
 TH2.cxx:3551
 TH2.cxx:3552
 TH2.cxx:3553
 TH2.cxx:3554
 TH2.cxx:3555
 TH2.cxx:3556
 TH2.cxx:3557
 TH2.cxx:3558
 TH2.cxx:3559
 TH2.cxx:3560
 TH2.cxx:3561
 TH2.cxx:3562
 TH2.cxx:3563
 TH2.cxx:3564
 TH2.cxx:3565
 TH2.cxx:3566
 TH2.cxx:3567
 TH2.cxx:3568
 TH2.cxx:3569
 TH2.cxx:3570
 TH2.cxx:3571
 TH2.cxx:3572
 TH2.cxx:3573
 TH2.cxx:3574
 TH2.cxx:3575
 TH2.cxx:3576
 TH2.cxx:3577
 TH2.cxx:3578
 TH2.cxx:3579
 TH2.cxx:3580
 TH2.cxx:3581
 TH2.cxx:3582
 TH2.cxx:3583
 TH2.cxx:3584
 TH2.cxx:3585
 TH2.cxx:3586
 TH2.cxx:3587
 TH2.cxx:3588
 TH2.cxx:3589
 TH2.cxx:3590
 TH2.cxx:3591
 TH2.cxx:3592
 TH2.cxx:3593
 TH2.cxx:3594
 TH2.cxx:3595
 TH2.cxx:3596
 TH2.cxx:3597
 TH2.cxx:3598
 TH2.cxx:3599
 TH2.cxx:3600
 TH2.cxx:3601
 TH2.cxx:3602
 TH2.cxx:3603
 TH2.cxx:3604
 TH2.cxx:3605
 TH2.cxx:3606
 TH2.cxx:3607
 TH2.cxx:3608
 TH2.cxx:3609
 TH2.cxx:3610
 TH2.cxx:3611
 TH2.cxx:3612
 TH2.cxx:3613
 TH2.cxx:3614
 TH2.cxx:3615
 TH2.cxx:3616
 TH2.cxx:3617
 TH2.cxx:3618
 TH2.cxx:3619
 TH2.cxx:3620
 TH2.cxx:3621
 TH2.cxx:3622
 TH2.cxx:3623
 TH2.cxx:3624
 TH2.cxx:3625
 TH2.cxx:3626
 TH2.cxx:3627
 TH2.cxx:3628
 TH2.cxx:3629
 TH2.cxx:3630
 TH2.cxx:3631
 TH2.cxx:3632
 TH2.cxx:3633
 TH2.cxx:3634
 TH2.cxx:3635
 TH2.cxx:3636
 TH2.cxx:3637
 TH2.cxx:3638
 TH2.cxx:3639
 TH2.cxx:3640
 TH2.cxx:3641
 TH2.cxx:3642
 TH2.cxx:3643
 TH2.cxx:3644
 TH2.cxx:3645
 TH2.cxx:3646
 TH2.cxx:3647
 TH2.cxx:3648
 TH2.cxx:3649
 TH2.cxx:3650
 TH2.cxx:3651
 TH2.cxx:3652
 TH2.cxx:3653
 TH2.cxx:3654
 TH2.cxx:3655
 TH2.cxx:3656
 TH2.cxx:3657
 TH2.cxx:3658
 TH2.cxx:3659
 TH2.cxx:3660
 TH2.cxx:3661
 TH2.cxx:3662
 TH2.cxx:3663
 TH2.cxx:3664
 TH2.cxx:3665
 TH2.cxx:3666
 TH2.cxx:3667
 TH2.cxx:3668
 TH2.cxx:3669
 TH2.cxx:3670
 TH2.cxx:3671
 TH2.cxx:3672
 TH2.cxx:3673
 TH2.cxx:3674
 TH2.cxx:3675
 TH2.cxx:3676
 TH2.cxx:3677
 TH2.cxx:3678
 TH2.cxx:3679
 TH2.cxx:3680
 TH2.cxx:3681
 TH2.cxx:3682
 TH2.cxx:3683
 TH2.cxx:3684
 TH2.cxx:3685
 TH2.cxx:3686
 TH2.cxx:3687
 TH2.cxx:3688
 TH2.cxx:3689
 TH2.cxx:3690
 TH2.cxx:3691
 TH2.cxx:3692
 TH2.cxx:3693
 TH2.cxx:3694
 TH2.cxx:3695
 TH2.cxx:3696
 TH2.cxx:3697
 TH2.cxx:3698
 TH2.cxx:3699
 TH2.cxx:3700
 TH2.cxx:3701
 TH2.cxx:3702
 TH2.cxx:3703
 TH2.cxx:3704
 TH2.cxx:3705
 TH2.cxx:3706
 TH2.cxx:3707
 TH2.cxx:3708
 TH2.cxx:3709
 TH2.cxx:3710
 TH2.cxx:3711
 TH2.cxx:3712
 TH2.cxx:3713
 TH2.cxx:3714
 TH2.cxx:3715
 TH2.cxx:3716
 TH2.cxx:3717
 TH2.cxx:3718
 TH2.cxx:3719
 TH2.cxx:3720
 TH2.cxx:3721
 TH2.cxx:3722
 TH2.cxx:3723
 TH2.cxx:3724
 TH2.cxx:3725
 TH2.cxx:3726
 TH2.cxx:3727
 TH2.cxx:3728
 TH2.cxx:3729
 TH2.cxx:3730
 TH2.cxx:3731
 TH2.cxx:3732
 TH2.cxx:3733
 TH2.cxx:3734
 TH2.cxx:3735
 TH2.cxx:3736
 TH2.cxx:3737
 TH2.cxx:3738
 TH2.cxx:3739
 TH2.cxx:3740
 TH2.cxx:3741
 TH2.cxx:3742
 TH2.cxx:3743
 TH2.cxx:3744
 TH2.cxx:3745
 TH2.cxx:3746
 TH2.cxx:3747
 TH2.cxx:3748
 TH2.cxx:3749
 TH2.cxx:3750
 TH2.cxx:3751
 TH2.cxx:3752
 TH2.cxx:3753
 TH2.cxx:3754
 TH2.cxx:3755
 TH2.cxx:3756
 TH2.cxx:3757
 TH2.cxx:3758
 TH2.cxx:3759
 TH2.cxx:3760
 TH2.cxx:3761
 TH2.cxx:3762
 TH2.cxx:3763
 TH2.cxx:3764
 TH2.cxx:3765
 TH2.cxx:3766
 TH2.cxx:3767
 TH2.cxx:3768
 TH2.cxx:3769
 TH2.cxx:3770
 TH2.cxx:3771
 TH2.cxx:3772
 TH2.cxx:3773
 TH2.cxx:3774
 TH2.cxx:3775
 TH2.cxx:3776
 TH2.cxx:3777
 TH2.cxx:3778
 TH2.cxx:3779
 TH2.cxx:3780
 TH2.cxx:3781
 TH2.cxx:3782
 TH2.cxx:3783
 TH2.cxx:3784
 TH2.cxx:3785
 TH2.cxx:3786
 TH2.cxx:3787
 TH2.cxx:3788
 TH2.cxx:3789
 TH2.cxx:3790
 TH2.cxx:3791
 TH2.cxx:3792
 TH2.cxx:3793
 TH2.cxx:3794
 TH2.cxx:3795
 TH2.cxx:3796
 TH2.cxx:3797
 TH2.cxx:3798
 TH2.cxx:3799
 TH2.cxx:3800
 TH2.cxx:3801
 TH2.cxx:3802
 TH2.cxx:3803
 TH2.cxx:3804
 TH2.cxx:3805
 TH2.cxx:3806
 TH2.cxx:3807
 TH2.cxx:3808
 TH2.cxx:3809
 TH2.cxx:3810
 TH2.cxx:3811
 TH2.cxx:3812
 TH2.cxx:3813
 TH2.cxx:3814
 TH2.cxx:3815
 TH2.cxx:3816
 TH2.cxx:3817
 TH2.cxx:3818
 TH2.cxx:3819
 TH2.cxx:3820
 TH2.cxx:3821
 TH2.cxx:3822
 TH2.cxx:3823
 TH2.cxx:3824
 TH2.cxx:3825
 TH2.cxx:3826
 TH2.cxx:3827
 TH2.cxx:3828
 TH2.cxx:3829
 TH2.cxx:3830
 TH2.cxx:3831
 TH2.cxx:3832
 TH2.cxx:3833
 TH2.cxx:3834
 TH2.cxx:3835
 TH2.cxx:3836
 TH2.cxx:3837
 TH2.cxx:3838
 TH2.cxx:3839
 TH2.cxx:3840
 TH2.cxx:3841
 TH2.cxx:3842
 TH2.cxx:3843
 TH2.cxx:3844
 TH2.cxx:3845
 TH2.cxx:3846
 TH2.cxx:3847
 TH2.cxx:3848
 TH2.cxx:3849
 TH2.cxx:3850
 TH2.cxx:3851
 TH2.cxx:3852
 TH2.cxx:3853
 TH2.cxx:3854
 TH2.cxx:3855
 TH2.cxx:3856
 TH2.cxx:3857
 TH2.cxx:3858
 TH2.cxx:3859
 TH2.cxx:3860
 TH2.cxx:3861
 TH2.cxx:3862
 TH2.cxx:3863
 TH2.cxx:3864
 TH2.cxx:3865
 TH2.cxx:3866
 TH2.cxx:3867
 TH2.cxx:3868
 TH2.cxx:3869
 TH2.cxx:3870
 TH2.cxx:3871
 TH2.cxx:3872
 TH2.cxx:3873
 TH2.cxx:3874
 TH2.cxx:3875
 TH2.cxx:3876
 TH2.cxx:3877
 TH2.cxx:3878
 TH2.cxx:3879
 TH2.cxx:3880
 TH2.cxx:3881
 TH2.cxx:3882
 TH2.cxx:3883
 TH2.cxx:3884
 TH2.cxx:3885
 TH2.cxx:3886
 TH2.cxx:3887
 TH2.cxx:3888
 TH2.cxx:3889
 TH2.cxx:3890
 TH2.cxx:3891
 TH2.cxx:3892
 TH2.cxx:3893
 TH2.cxx:3894
 TH2.cxx:3895
 TH2.cxx:3896
 TH2.cxx:3897
 TH2.cxx:3898
 TH2.cxx:3899
 TH2.cxx:3900
 TH2.cxx:3901
 TH2.cxx:3902
 TH2.cxx:3903
 TH2.cxx:3904
 TH2.cxx:3905
 TH2.cxx:3906
 TH2.cxx:3907
 TH2.cxx:3908
 TH2.cxx:3909
 TH2.cxx:3910
 TH2.cxx:3911
 TH2.cxx:3912
 TH2.cxx:3913
 TH2.cxx:3914
 TH2.cxx:3915
 TH2.cxx:3916
 TH2.cxx:3917
 TH2.cxx:3918
 TH2.cxx:3919
 TH2.cxx:3920
 TH2.cxx:3921
 TH2.cxx:3922
 TH2.cxx:3923
 TH2.cxx:3924
 TH2.cxx:3925
 TH2.cxx:3926
 TH2.cxx:3927
 TH2.cxx:3928
 TH2.cxx:3929
 TH2.cxx:3930
 TH2.cxx:3931
 TH2.cxx:3932
 TH2.cxx:3933
 TH2.cxx:3934
 TH2.cxx:3935
 TH2.cxx:3936
 TH2.cxx:3937
 TH2.cxx:3938
 TH2.cxx:3939
 TH2.cxx:3940
 TH2.cxx:3941
 TH2.cxx:3942
 TH2.cxx:3943
 TH2.cxx:3944
 TH2.cxx:3945
 TH2.cxx:3946
 TH2.cxx:3947
 TH2.cxx:3948
 TH2.cxx:3949
 TH2.cxx:3950
 TH2.cxx:3951
 TH2.cxx:3952
 TH2.cxx:3953
 TH2.cxx:3954
 TH2.cxx:3955
 TH2.cxx:3956
 TH2.cxx:3957
 TH2.cxx:3958
 TH2.cxx:3959
 TH2.cxx:3960
 TH2.cxx:3961
 TH2.cxx:3962
 TH2.cxx:3963
 TH2.cxx:3964
 TH2.cxx:3965
 TH2.cxx:3966
 TH2.cxx:3967
 TH2.cxx:3968
 TH2.cxx:3969
 TH2.cxx:3970
 TH2.cxx:3971
 TH2.cxx:3972
 TH2.cxx:3973
 TH2.cxx:3974
 TH2.cxx:3975
 TH2.cxx:3976
 TH2.cxx:3977
 TH2.cxx:3978
 TH2.cxx:3979
 TH2.cxx:3980
 TH2.cxx:3981
 TH2.cxx:3982
 TH2.cxx:3983
 TH2.cxx:3984
 TH2.cxx:3985
 TH2.cxx:3986
 TH2.cxx:3987
 TH2.cxx:3988
 TH2.cxx:3989
 TH2.cxx:3990
 TH2.cxx:3991
 TH2.cxx:3992
 TH2.cxx:3993
 TH2.cxx:3994
 TH2.cxx:3995
 TH2.cxx:3996
 TH2.cxx:3997
 TH2.cxx:3998
 TH2.cxx:3999
 TH2.cxx:4000
 TH2.cxx:4001
 TH2.cxx:4002
 TH2.cxx:4003
 TH2.cxx:4004
 TH2.cxx:4005
 TH2.cxx:4006
 TH2.cxx:4007
 TH2.cxx:4008
 TH2.cxx:4009
 TH2.cxx:4010
 TH2.cxx:4011
 TH2.cxx:4012
 TH2.cxx:4013
 TH2.cxx:4014
 TH2.cxx:4015
 TH2.cxx:4016
 TH2.cxx:4017
 TH2.cxx:4018
 TH2.cxx:4019
 TH2.cxx:4020
 TH2.cxx:4021
 TH2.cxx:4022
 TH2.cxx:4023
 TH2.cxx:4024
 TH2.cxx:4025
 TH2.cxx:4026
 TH2.cxx:4027
 TH2.cxx:4028
 TH2.cxx:4029
 TH2.cxx:4030
 TH2.cxx:4031
 TH2.cxx:4032
 TH2.cxx:4033
 TH2.cxx:4034
 TH2.cxx:4035
 TH2.cxx:4036
 TH2.cxx:4037
 TH2.cxx:4038
 TH2.cxx:4039
 TH2.cxx:4040
 TH2.cxx:4041
 TH2.cxx:4042
 TH2.cxx:4043
 TH2.cxx:4044
 TH2.cxx:4045
 TH2.cxx:4046
 TH2.cxx:4047
 TH2.cxx:4048
 TH2.cxx:4049
 TH2.cxx:4050
 TH2.cxx:4051
 TH2.cxx:4052
 TH2.cxx:4053
 TH2.cxx:4054
 TH2.cxx:4055
 TH2.cxx:4056
 TH2.cxx:4057
 TH2.cxx:4058
 TH2.cxx:4059
 TH2.cxx:4060
 TH2.cxx:4061
 TH2.cxx:4062
 TH2.cxx:4063
 TH2.cxx:4064
 TH2.cxx:4065
 TH2.cxx:4066
 TH2.cxx:4067
 TH2.cxx:4068
 TH2.cxx:4069
 TH2.cxx:4070
 TH2.cxx:4071
 TH2.cxx:4072
 TH2.cxx:4073
 TH2.cxx:4074
 TH2.cxx:4075
 TH2.cxx:4076
 TH2.cxx:4077
 TH2.cxx:4078
 TH2.cxx:4079
 TH2.cxx:4080
 TH2.cxx:4081
 TH2.cxx:4082
 TH2.cxx:4083
 TH2.cxx:4084
 TH2.cxx:4085
 TH2.cxx:4086
 TH2.cxx:4087
 TH2.cxx:4088
 TH2.cxx:4089
 TH2.cxx:4090
 TH2.cxx:4091
 TH2.cxx:4092
 TH2.cxx:4093
 TH2.cxx:4094
 TH2.cxx:4095
 TH2.cxx:4096
 TH2.cxx:4097
 TH2.cxx:4098
 TH2.cxx:4099
 TH2.cxx:4100
 TH2.cxx:4101
 TH2.cxx:4102
 TH2.cxx:4103
 TH2.cxx:4104
 TH2.cxx:4105
 TH2.cxx:4106
 TH2.cxx:4107
 TH2.cxx:4108
 TH2.cxx:4109
 TH2.cxx:4110
 TH2.cxx:4111
 TH2.cxx:4112
 TH2.cxx:4113
 TH2.cxx:4114
 TH2.cxx:4115
 TH2.cxx:4116
 TH2.cxx:4117
 TH2.cxx:4118
 TH2.cxx:4119
 TH2.cxx:4120
 TH2.cxx:4121
 TH2.cxx:4122
 TH2.cxx:4123
 TH2.cxx:4124
 TH2.cxx:4125