// @(#)root/hist:$Id$
// Author: Rene Brun   27/10/95

/*************************************************************************
 * 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 "TH3.h"
#include "TProfile2D.h"
#include "TH2.h"
#include "TF1.h"
#include "TVirtualPad.h"
#include "TVirtualHistPainter.h"
#include "THLimitsFinder.h"
#include "TRandom.h"
#include "TError.h"
#include "TMath.h"
#include "TObjString.h"

ClassImp(TH3)


//______________________________________________________________________________
//
//  The 3-D histogram classes derived from the 1-D histogram classes.
//  all operations are supported (fill, fit).
//  Drawing is currently restricted to one single option.
//  A cloud of points is drawn. The number of points is proportional to
//  cell content.
//
//
//  TH3C a 3-D histogram with one byte per cell (char)
//  TH3S a 3-D histogram with two bytes per cell (short integer)
//  TH3I a 3-D histogram with four bytes per cell (32 bits integer)
//  TH3F a 3-D histogram with four bytes per cell (float)
//  TH3D a 3-D histogram with eight bytes per cell (double)


//______________________________________________________________________________
TH3::TH3()
{
   // Default constructor.
   fDimension   = 3;
   fTsumwy      = fTsumwy2 = fTsumwxy = 0;
   fTsumwz      = fTsumwz2 = fTsumwxz = fTsumwyz = 0;
}


//______________________________________________________________________________
TH3::TH3(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
                                     ,Int_t nbinsy,Double_t ylow,Double_t yup
                                     ,Int_t nbinsz,Double_t zlow,Double_t zup)
     :TH1(name,title,nbinsx,xlow,xup),
      TAtt3D()
{
   // Normal constructor for fix bin size 3-D histograms.

   fDimension   = 3;
   if (nbinsy <= 0) {Warning("TH3","nbinsy is <=0 - set to nbinsy = 1"); nbinsy = 1; }
   if (nbinsz <= 0) nbinsz = 1;
   fYaxis.Set(nbinsy,ylow,yup);
   fZaxis.Set(nbinsz,zlow,zup);
   fNcells      = (nbinsx+2)*(nbinsy+2)*(nbinsz+2);
   fTsumwy      = fTsumwy2 = fTsumwxy = 0;
   fTsumwz      = fTsumwz2 = fTsumwxz = fTsumwyz = 0;
}


//______________________________________________________________________________
TH3::TH3(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
                                           ,Int_t nbinsy,const Float_t *ybins
                                           ,Int_t nbinsz,const Float_t *zbins)
     :TH1(name,title,nbinsx,xbins),
      TAtt3D()
{
   // Normal constructor for variable bin size 3-D histograms.

   fDimension   = 3;
   if (nbinsy <= 0) {Warning("TH3","nbinsy is <=0 - set to nbinsy = 1"); nbinsy = 1; }
   if (nbinsz <= 0) nbinsz = 1;
   if (ybins) fYaxis.Set(nbinsy,ybins);
   else       fYaxis.Set(nbinsy,0,1);
   if (zbins) fZaxis.Set(nbinsz,zbins);
   else       fZaxis.Set(nbinsz,0,1);
   fNcells      = (nbinsx+2)*(nbinsy+2)*(nbinsz+2);
   fTsumwy      = fTsumwy2 = fTsumwxy = 0;
   fTsumwz      = fTsumwz2 = fTsumwxz = fTsumwyz = 0;
}


//______________________________________________________________________________
TH3::TH3(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
                                           ,Int_t nbinsy,const Double_t *ybins
                                           ,Int_t nbinsz,const Double_t *zbins)
     :TH1(name,title,nbinsx,xbins),
      TAtt3D()
{
   // Normal constructor for variable bin size 3-D histograms.

   fDimension   = 3;
   if (nbinsy <= 0) {Warning("TH3","nbinsy is <=0 - set to nbinsy = 1"); nbinsy = 1; }
   if (nbinsz <= 0) nbinsz = 1;
   if (ybins) fYaxis.Set(nbinsy,ybins);
   else       fYaxis.Set(nbinsy,0,1);
   if (zbins) fZaxis.Set(nbinsz,zbins);
   else       fZaxis.Set(nbinsz,0,1);
   fNcells      = (nbinsx+2)*(nbinsy+2)*(nbinsz+2);
   fTsumwy      = fTsumwy2 = fTsumwxy = 0;
   fTsumwz      = fTsumwz2 = fTsumwxz = fTsumwyz = 0;
}


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

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


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


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

   TH1::Copy(obj);
   ((TH3&)obj).fTsumwy      = fTsumwy;
   ((TH3&)obj).fTsumwy2     = fTsumwy2;
   ((TH3&)obj).fTsumwxy     = fTsumwxy;
   ((TH3&)obj).fTsumwz      = fTsumwz;
   ((TH3&)obj).fTsumwz2     = fTsumwz2;
   ((TH3&)obj).fTsumwxz     = fTsumwxz;
   ((TH3&)obj).fTsumwyz     = fTsumwyz;
}


//______________________________________________________________________________
Int_t TH3::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];
   if (!nbentries) return 0;
   Double_t *buffer = fBuffer;
   if (nbentries < 0) {
      if (action == 0) return 0;
      nbentries  = -nbentries;
      fBuffer=0;
      Reset("ICES");
      fBuffer = buffer;
   }
   if (CanExtendAllAxes() || fXaxis.GetXmax() <= fXaxis.GetXmin() ||
      fYaxis.GetXmax() <= fYaxis.GetXmin() ||
      fZaxis.GetXmax() <= fZaxis.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;
         Double_t zmin = fBuffer[4];
         Double_t zmax = zmin;
         for (Int_t i=1;i<nbentries;i++) {
            Double_t x = fBuffer[4*i+2];
            if (x < xmin) xmin = x;
            if (x > xmax) xmax = x;
            Double_t y = fBuffer[4*i+3];
            if (y < ymin) ymin = y;
            if (y > ymax) ymax = y;
            Double_t z = fBuffer[4*i+4];
            if (z < zmin) zmin = z;
            if (z > zmax) zmax = z;
         }
         if (fXaxis.GetXmax() <= fXaxis.GetXmin() || fYaxis.GetXmax() <= fYaxis.GetXmin() || fZaxis.GetXmax() <= fZaxis.GetXmin()) {
            THLimitsFinder::GetLimitsFinder()->FindGoodLimits(this,xmin,xmax,ymin,ymax,zmin,zmax);
         } 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);
            if (zmin <  fZaxis.GetXmin()) ExtendAxis(zmin,&fZaxis);
            if (zmax >= fZaxis.GetXmax()) ExtendAxis(zmax,&fZaxis);
            fBuffer = buffer;
            fBufferSize = keep;
         }
   }
   fBuffer = 0;

   for (Int_t i=0;i<nbentries;i++) {
      Fill(buffer[4*i+2],buffer[4*i+3],buffer[4*i+4],buffer[4*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 TH3::BufferFill(Double_t x, Double_t y, Double_t z, 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
   // fBuffer[4] = z 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 (4*nbentries+4 >= fBufferSize) {
      BufferEmpty(1);
      return Fill(x,y,z,w);
   }
   fBuffer[4*nbentries+1] = w;
   fBuffer[4*nbentries+2] = x;
   fBuffer[4*nbentries+3] = y;
   fBuffer[4*nbentries+4] = z;
   fBuffer[0] += 1;
   return -3;
}


//______________________________________________________________________________
Int_t TH3::Fill(Double_t )
{
   // Invalid Fill method
   Error("Fill", "Invalid signature - do nothing");
   return -1;
}


//______________________________________________________________________________
Int_t TH3::Fill(Double_t x, Double_t y, Double_t z)
{
   // Increment cell defined by x,y,z by 1 .
   //
   // The function returns the corresponding global bin number which has its content
   // incremented by 1

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

   Int_t binx, biny, binz, bin;
   fEntries++;
   binx = fXaxis.FindBin(x);
   biny = fYaxis.FindBin(y);
   binz = fZaxis.FindBin(z);
   if (binx <0 || biny <0 || binz<0) return -1;
   bin  =  binx + (fXaxis.GetNbins()+2)*(biny + (fYaxis.GetNbins()+2)*binz);
   if (fSumw2.fN) ++fSumw2.fArray[bin];
   AddBinContent(bin);
   if (binx == 0 || binx > fXaxis.GetNbins()) {
      if (!fgStatOverflows) return -1;
   }

   if (biny == 0 || biny > fYaxis.GetNbins()) {
      if (!fgStatOverflows) return -1;
   }
   if (binz == 0 || binz > fZaxis.GetNbins()) {
      if (!fgStatOverflows) return -1;
   }
   ++fTsumw;
   ++fTsumw2;
   fTsumwx  += x;
   fTsumwx2 += x*x;
   fTsumwy  += y;
   fTsumwy2 += y*y;
   fTsumwxy += x*y;
   fTsumwz  += z;
   fTsumwz2 += z*z;
   fTsumwxz += x*z;
   fTsumwyz += y*z;
   return bin;
}


//______________________________________________________________________________
Int_t TH3::Fill(Double_t x, Double_t y, Double_t z, Double_t w)
{
   // Increment cell defined by x,y,z by a weight 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^2 in the cell corresponding to x,y,z.
   //
   // The function returns the corresponding global bin number which has its content
   // incremented by w

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

   Int_t binx, biny, binz, bin;
   fEntries++;
   binx = fXaxis.FindBin(x);
   biny = fYaxis.FindBin(y);
   binz = fZaxis.FindBin(z);
   if (binx <0 || biny <0 || binz<0) return -1;
   bin  =  binx + (fXaxis.GetNbins()+2)*(biny + (fYaxis.GetNbins()+2)*binz);
   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;
   }
   if (binz == 0 || binz > fZaxis.GetNbins()) {
      if (!fgStatOverflows) return -1;
   }
   fTsumw   += w;
   fTsumw2  += w*w;
   fTsumwx  += w*x;
   fTsumwx2 += w*x*x;
   fTsumwy  += w*y;
   fTsumwy2 += w*y*y;
   fTsumwxy += w*x*y;
   fTsumwz  += w*z;
   fTsumwz2 += w*z*z;
   fTsumwxz += w*x*z;
   fTsumwyz += w*y*z;
   return bin;
}


//______________________________________________________________________________
Int_t TH3::Fill(const char *namex, const char *namey, const char *namez, Double_t w)
{
   // Increment cell defined by namex,namey,namez by a weight 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^2 in the corresponding cell.
   // The function returns the corresponding global bin number which has its content
   // incremented by w

   Int_t binx, biny, binz, bin;
   fEntries++;
   binx = fXaxis.FindBin(namex);
   biny = fYaxis.FindBin(namey);
   binz = fZaxis.FindBin(namez);
   if (binx <0 || biny <0 || binz<0) return -1;
   bin  =  binx + (fXaxis.GetNbins()+2)*(biny + (fYaxis.GetNbins()+2)*binz);
   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;
   if (binz == 0 || binz > fZaxis.GetNbins()) return -1;
   Double_t x = fXaxis.GetBinCenter(binx);
   Double_t y = fYaxis.GetBinCenter(biny);
   Double_t z = fZaxis.GetBinCenter(binz);
   Double_t v = w;
   fTsumw   += v;
   fTsumw2  += v*v;
   fTsumwx  += v*x;
   fTsumwx2 += v*x*x;
   fTsumwy  += v*y;
   fTsumwy2 += v*y*y;
   fTsumwxy += v*x*y;
   fTsumwz  += v*z;
   fTsumwz2 += v*z*z;
   fTsumwxz += v*x*z;
   fTsumwyz += v*y*z;
   return bin;
}


//______________________________________________________________________________
Int_t TH3::Fill(const char *namex, Double_t y, const char *namez, Double_t w)
{
   // Increment cell defined by namex,y,namez by a weight 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^2 in the corresponding cell.
   // The function returns the corresponding global bin number which has its content
   // incremented by w

   Int_t binx, biny, binz, bin;
   fEntries++;
   binx = fXaxis.FindBin(namex);
   biny = fYaxis.FindBin(y);
   binz = fZaxis.FindBin(namez);
   if (binx <0 || biny <0 || binz<0) return -1;
   bin  =  binx + (fXaxis.GetNbins()+2)*(biny + (fYaxis.GetNbins()+2)*binz);
   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;
   }
   if (binz == 0 || binz > fZaxis.GetNbins()) return -1;
   Double_t x = fXaxis.GetBinCenter(binx);
   Double_t z = fZaxis.GetBinCenter(binz);
   Double_t v = w;
   fTsumw   += v;
   fTsumw2  += v*v;
   fTsumwx  += v*x;
   fTsumwx2 += v*x*x;
   fTsumwy  += v*y;
   fTsumwy2 += v*y*y;
   fTsumwxy += v*x*y;
   fTsumwz  += v*z;
   fTsumwz2 += v*z*z;
   fTsumwxz += v*x*z;
   fTsumwyz += v*y*z;
   return bin;
}


//______________________________________________________________________________
Int_t TH3::Fill(const char *namex, const char *namey, Double_t z, Double_t w)
{
   // Increment cell defined by namex,namey,z by a weight 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^2 in the corresponding cell.
   // The function returns the corresponding global bin number which has its content
   // incremented by w

   Int_t binx, biny, binz, bin;
   fEntries++;
   binx = fXaxis.FindBin(namex);
   biny = fYaxis.FindBin(namey);
   binz = fZaxis.FindBin(z);
   if (binx <0 || biny <0 || binz<0) return -1;
   bin  =  binx + (fXaxis.GetNbins()+2)*(biny + (fYaxis.GetNbins()+2)*binz);
   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;
   if (binz == 0 || binz > fZaxis.GetNbins()) {
      if (!fgStatOverflows) return -1;
   }
   Double_t x = fXaxis.GetBinCenter(binx);
   Double_t y = fYaxis.GetBinCenter(biny);
   Double_t v = w;
   fTsumw   += v;
   fTsumw2  += v*v;
   fTsumwx  += v*x;
   fTsumwx2 += v*x*x;
   fTsumwy  += v*y;
   fTsumwy2 += v*y*y;
   fTsumwxy += v*x*y;
   fTsumwz  += v*z;
   fTsumwz2 += v*z*z;
   fTsumwxz += v*x*z;
   fTsumwyz += v*y*z;
   return bin;
}


//______________________________________________________________________________
Int_t TH3::Fill(Double_t x, const char *namey, const char *namez, Double_t w)
{
   // Increment cell defined by x,namey,namezz by a weight 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^2 in the corresponding cell.
   // The function returns the corresponding global bin number which has its content
   // incremented by w

   Int_t binx, biny, binz, bin;
   fEntries++;
   binx = fXaxis.FindBin(x);
   biny = fYaxis.FindBin(namey);
   binz = fZaxis.FindBin(namez);
   if (binx <0 || biny <0 || binz<0) return -1;
   bin  =  binx + (fXaxis.GetNbins()+2)*(biny + (fYaxis.GetNbins()+2)*binz);
   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;
   if (binz == 0 || binz > fZaxis.GetNbins()) return -1;
   Double_t y = fYaxis.GetBinCenter(biny);
   Double_t z = fZaxis.GetBinCenter(binz);
   Double_t v = w;
   fTsumw   += v;
   fTsumw2  += v*v;
   fTsumwx  += v*x;
   fTsumwx2 += v*x*x;
   fTsumwy  += v*y;
   fTsumwy2 += v*y*y;
   fTsumwxy += v*x*y;
   fTsumwz  += v*z;
   fTsumwz2 += v*z*z;
   fTsumwxz += v*x*z;
   fTsumwyz += v*y*z;
   return bin;
}


//______________________________________________________________________________
Int_t TH3::Fill(Double_t x, const char *namey, Double_t z, Double_t w)
{
   // Increment cell defined by x,namey,z by a weight 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^2 in the corresponding cell.
   // The function returns the corresponding global bin number which has its content
   // incremented by w

   Int_t binx, biny, binz, bin;
   fEntries++;
   binx = fXaxis.FindBin(x);
   biny = fYaxis.FindBin(namey);
   binz = fZaxis.FindBin(z);
   if (binx <0 || biny <0 || binz<0) return -1;
   bin  =  binx + (fXaxis.GetNbins()+2)*(biny + (fYaxis.GetNbins()+2)*binz);
   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;
   if (binz == 0 || binz > fZaxis.GetNbins()) {
      if (!fgStatOverflows) return -1;
   }
   Double_t y = fYaxis.GetBinCenter(biny);
   Double_t v = w;
   fTsumw   += v;
   fTsumw2  += v*v;
   fTsumwx  += v*x;
   fTsumwx2 += v*x*x;
   fTsumwy  += v*y;
   fTsumwy2 += v*y*y;
   fTsumwxy += v*x*y;
   fTsumwz  += v*z;
   fTsumwz2 += v*z*z;
   fTsumwxz += v*x*z;
   fTsumwyz += v*y*z;
   return bin;
}


//______________________________________________________________________________
Int_t TH3::Fill(Double_t x, Double_t y, const char *namez, Double_t w)
{
   // Increment cell defined by x,y,namez by a weight 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^2 in the corresponding cell.
   // The function returns the corresponding global bin number which has its content
   // incremented by w

   Int_t binx, biny, binz, bin;
   fEntries++;
   binx = fXaxis.FindBin(x);
   biny = fYaxis.FindBin(y);
   binz = fZaxis.FindBin(namez);
   if (binx <0 || biny <0 || binz<0) return -1;
   bin  =  binx + (fXaxis.GetNbins()+2)*(biny + (fYaxis.GetNbins()+2)*binz);
   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;
   }
   if (binz == 0 || binz > fZaxis.GetNbins()) return -1;
   Double_t z = fZaxis.GetBinCenter(binz);
   Double_t v = w;
   fTsumw   += v;
   fTsumw2  += v*v;
   fTsumwx  += v*x;
   fTsumwx2 += v*x*x;
   fTsumwy  += v*y;
   fTsumwy2 += v*y*y;
   fTsumwxy += v*x*y;
   fTsumwz  += v*z;
   fTsumwz2 += v*z*z;
   fTsumwxz += v*x*z;
   fTsumwyz += v*y*z;
   return bin;
}


//______________________________________________________________________________
void TH3::FillRandom(const char *fname, Int_t ntimes)
{
   // Fill histogram following distribution in function fname.
   //
   //   The distribution contained in the function fname (TF1) 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 TF1::GetRandom to get a random variate from a function.

   Int_t bin, binx, biny, binz, ibin, loop;
   Double_t r1, x, y,z, xv[3];
   //  Search for fname in the list of ROOT defined functions
   TF1 *f1 = (TF1*)gROOT->GetFunction(fname);
   if (!f1) { Error("FillRandom", "Unknown function: %s",fname); return; }

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

   Double_t *integral = new Double_t[nbins+1];
   ibin = 0;
   integral[ibin] = 0;
   for (binz=1;binz<=nbinsz;binz++) {
      xv[2] = fZaxis.GetBinCenter(binz);
      for (biny=1;biny<=nbinsy;biny++) {
         xv[1] = fYaxis.GetBinCenter(biny);
         for (binx=1;binx<=nbinsx;binx++) {
            xv[0] = fXaxis.GetBinCenter(binx);
            ibin++;
            integral[ibin] = integral[ibin-1] + f1->Eval(xv[0],xv[1],xv[2]);
         }
      }
   }

   //  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
   if (fDimension < 2) nbinsy = -1;
   if (fDimension < 3) nbinsz = -1;
   for (loop=0;loop<ntimes;loop++) {
      r1 = gRandom->Rndm(loop);
      ibin = TMath::BinarySearch(nbins,&integral[0],r1);
      binz = ibin/nxy;
      biny = (ibin - nxy*binz)/nbinsx;
      binx = 1 + ibin - nbinsx*(biny + nbinsy*binz);
      if (nbinsz) binz++;
      if (nbinsy) biny++;
      x    = fXaxis.GetBinCenter(binx);
      y    = fYaxis.GetBinCenter(biny);
      z    = fZaxis.GetBinCenter(binz);
      Fill(x,y,z, 1.);
   }
   delete [] integral;
}


//______________________________________________________________________________
void TH3::FillRandom(TH1 *h, Int_t ntimes)
{
   // Fill histogram following distribution in histogram h.
   //
   //   The distribution contained in the histogram h (TH3) 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;

   TH3 *h3 = (TH3*)h;
   Int_t loop;
   Double_t x,y,z;
   for (loop=0;loop<ntimes;loop++) {
      h3->GetRandom3(x,y,z);
      Fill(x,y,z);
   }
}


//______________________________________________________________________________
Int_t TH3::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 > 3) {
      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 nbinsz = fZaxis.GetNbins();
   Int_t binx, biny, binz;
   if (axis == 1) {
      for (binx=1;binx<=nbinsx;binx++) {
         for (biny=1;biny<=nbinsy;biny++) {
            for (binz=1;binz<=nbinsz;binz++) {
               if (GetBinContent(binx,biny,binz) > threshold) return binx;
            }
         }
      }
   } else if (axis == 2) {
      for (biny=1;biny<=nbinsy;biny++) {
         for (binx=1;binx<=nbinsx;binx++) {
            for (binz=1;binz<=nbinsz;binz++) {
               if (GetBinContent(binx,biny,binz) > threshold) return biny;
            }
         }
      }
   } else {
      for (binz=1;binz<=nbinsz;binz++) {
         for (binx=1;binx<=nbinsx;binx++) {
            for (biny=1;biny<=nbinsy;biny++) {
               if (GetBinContent(binx,biny,binz) > threshold) return binz;
            }
         }
      }
   }
   return -1;
}


//______________________________________________________________________________
Int_t TH3::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 > 3) {
      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 nbinsz = fZaxis.GetNbins();
   Int_t binx, biny, binz;
   if (axis == 1) {
      for (binx=nbinsx;binx>=1;binx--) {
         for (biny=1;biny<=nbinsy;biny++) {
            for (binz=1;binz<=nbinsz;binz++) {
               if (GetBinContent(binx,biny,binz) > threshold) return binx;
            }
         }
      }
   } else if (axis == 2) {
      for (biny=nbinsy;biny>=1;biny--) {
         for (binx=1;binx<=nbinsx;binx++) {
            for (binz=1;binz<=nbinsz;binz++) {
               if (GetBinContent(binx,biny,binz) > threshold) return biny;
            }
         }
      }
   } else {
      for (binz=nbinsz;binz>=1;binz--) {
         for (binx=1;binx<=nbinsx;binx++) {
            for (biny=1;biny<=nbinsy;biny++) {
               if (GetBinContent(binx,biny,binz) > threshold) return binz;
            }
         }
      }
   }
   return -1;
}


//______________________________________________________________________________
void TH3::FitSlicesZ(TF1 *f1, Int_t binminx, Int_t binmaxx, Int_t binminy, Int_t binmaxy, Int_t cut, Option_t *option)
{
   // Project slices along Z in case of a 3-D histogram, then fit each slice
   // with function f1 and make a 2-d histogram for each fit parameter
   // Only cells in the bin range [binminx,binmaxx] and [binminy,binmaxy] are considered.
   // if f1=0, a gaussian is assumed
   // Before invoking this function, one can set a subrange to be fitted along Z
   // via f1->SetRange(zmin,zmax)
   // 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
   //
   // Note that 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 3-d histogram h3
   //   Root > h3->FitSlicesZ(); produces 4 TH2D histograms
   //          with h3_0 containing parameter 0(Constant) for a Gaus fit
   //                    of each cell in X,Y projected along Z
   //          with h3_1 containing parameter 1(Mean) for a gaus fit
   //          with h3_2 containing parameter 2(RMS)  for a gaus fit
   //          with h3_chi2 containing the chisquare/number of degrees of freedom for a gaus fit
   //
   //   Root > h3->Fit(0,15,22,0,0,10);
   //          same as above, but only for bins 15 to 22 along X
   //          and only for cells in X,Y for which the corresponding projection
   //          along Z has more than cut bins filled.
   //
   //  NOTE: To access the generated histograms in the current directory, do eg:
   //     TH2D *h3_1 = (TH2D*)gDirectory->Get("h3_1");

   Int_t nbinsx  = fXaxis.GetNbins();
   Int_t nbinsy  = fYaxis.GetNbins();
   Int_t nbinsz  = fZaxis.GetNbins();
   if (binminx < 1) binminx = 1;
   if (binmaxx > nbinsx) binmaxx = nbinsx;
   if (binmaxx < binminx) {binminx = 1; binmaxx = nbinsx;}
   if (binminy < 1) binminy = 1;
   if (binmaxy > nbinsy) binmaxy = nbinsy;
   if (binmaxy < binminy) {binminy = 1; binmaxy = nbinsy;}

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

   //Create one 2-d histogram for each function parameter
   Int_t ipar;
   char name[80], title[80];
   TH2D *hlist[25];
   const TArrayD *xbins = fXaxis.GetXbins();
   const TArrayD *ybins = fYaxis.GetXbins();
   for (ipar=0;ipar<npar;ipar++) {
      snprintf(name,80,"%s_%d",GetName(),ipar);
      snprintf(title,80,"Fitted value of par[%d]=%s",ipar,f1->GetParName(ipar));
      if (xbins->fN == 0) {
         hlist[ipar] = new TH2D(name, title,
                                nbinsx, fXaxis.GetXmin(), fXaxis.GetXmax(),
                                nbinsy, fYaxis.GetXmin(), fYaxis.GetXmax());
      } else {
         hlist[ipar] = new TH2D(name, title,
                                nbinsx, xbins->fArray,
                                nbinsy, ybins->fArray);
      }
      hlist[ipar]->GetXaxis()->SetTitle(fXaxis.GetTitle());
      hlist[ipar]->GetYaxis()->SetTitle(fYaxis.GetTitle());
   }
   snprintf(name,80,"%s_chi2",GetName());
   TH2D *hchi2 = new TH2D(name,"chisquare", nbinsx, fXaxis.GetXmin(), fXaxis.GetXmax()
      , nbinsy, fYaxis.GetXmin(), fYaxis.GetXmax());

   //Loop on all cells in X,Y generate a projection along Z
   TH1D *hpz = new TH1D("R_temp","_temp",nbinsz, fZaxis.GetXmin(), fZaxis.GetXmax());
   Int_t bin,binx,biny,binz;
   for (biny=binminy;biny<=binmaxy;biny++) {
      Float_t y = fYaxis.GetBinCenter(biny);
      for (binx=binminx;binx<=binmaxx;binx++) {
         Float_t x = fXaxis.GetBinCenter(binx);
         hpz->Reset();
         Int_t nfill = 0;
         for (binz=1;binz<=nbinsz;binz++) {
            bin = GetBin(binx,biny,binz);
            Float_t w = RetrieveBinContent(bin);
            if (w == 0) continue;
            hpz->Fill(fZaxis.GetBinCenter(binz),w);
            hpz->SetBinError(binz,GetBinError(bin));
            nfill++;
         }
         if (nfill < cut) continue;
         f1->SetParameters(parsave);
         hpz->Fit(fname,option);
         Int_t npfits = f1->GetNumberFitPoints();
         if (npfits > npar && npfits >= cut) {
            for (ipar=0;ipar<npar;ipar++) {
               hlist[ipar]->Fill(x,y,f1->GetParameter(ipar));
               hlist[ipar]->SetBinError(binx,biny,f1->GetParError(ipar));
            }
            hchi2->SetBinContent(binx,biny,f1->GetChisquare()/(npfits-npar));
         }
      }
   }
   delete [] parsave;
   delete hpz;
}


//______________________________________________________________________________
Int_t TH3::GetBin(Int_t binx, Int_t biny, Int_t binz) const
{
   // See comments in TH1::GetBin

   Int_t ofy = fYaxis.GetNbins() + 1; // code duplication unavoidable because TH3 does not inherit from TH2
   if (biny < 0) biny = 0;
   if (biny > ofy) biny = ofy;

   Int_t ofz = fZaxis.GetNbins() + 1; // overflow bin
   if (binz < 0) binz = 0;
   if (binz > ofz) binz = ofz;

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


//______________________________________________________________________________
Double_t TH3::GetBinWithContent3(Double_t c, Int_t &binx, Int_t &biny, Int_t &binz,
                                 Int_t firstx, Int_t lastx,
                                 Int_t firsty, Int_t lasty,
                                 Int_t firstz, Int_t lastz,
                                 Double_t maxdiff) const
{
   // Compute first cell (binx,biny,binz) in the range [firstx,lastx](firsty,lasty][firstz,lastz] 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,binz.
   // In case several cells in the specified range satisfy diff <=maxdiff
   // the cell with the smallest difference is returned in binx,biny,binz.
   // In all cases the function returns the smallest difference.
   //
   // NOTE1: if firstx <= 0, firstx is set to bin 1
   //        if (lastx < firstx then firstx is set to the number of bins in X
   //        ie if firstx=0 and lastx=0 (default) the search is on all bins in X.
   //        if firsty <= 0, firsty is set to bin 1
   //        if (lasty < firsty then firsty is set to the number of bins in Y
   //        ie if firsty=0 and lasty=0 (default) the search is on all bins in Y.
   //        if firstz <= 0, firstz is set to bin 1
   //        if (lastz < firstz then firstz is set to the number of bins in Z
   //        ie if firstz=0 and lastz=0 (default) the search is on all bins in Z.
   // NOTE2: if maxdiff=0 (default), the first cell with content=c is returned.

   if (fDimension != 3) {
      binx = 0;
      biny = 0;
      binz = 0;
      Error("GetBinWithContent3","function is only valid for 3-D histograms");
      return 0;
   }
   if (firstx <= 0) firstx = 1;
   if (lastx < firstx) lastx = fXaxis.GetNbins();
   if (firsty <= 0) firsty = 1;
   if (lasty < firsty) lasty = fYaxis.GetNbins();
   if (firstz <= 0) firstz = 1;
   if (lastz < firstz) lastz = fZaxis.GetNbins();
   Int_t binminx = 0, binminy=0, binminz=0;
   Double_t diff, curmax = 1.e240;
   for (Int_t k=firstz;k<=lastz;k++) {
      for (Int_t j=firsty;j<=lasty;j++) {
         for (Int_t i=firstx;i<=lastx;i++) {
            diff = TMath::Abs(GetBinContent(i,j,k)-c);
            if (diff <= 0) {binx = i; biny=j; binz=k; return diff;}
            if (diff < curmax && diff <= maxdiff) {curmax = diff, binminx=i; binminy=j;binminz=k;}
         }
      }
   }
   binx = binminx;
   biny = binminy;
   binz = binminz;
   return curmax;
}


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

   if (axis1 < 1 || axis2 < 1 || axis1 > 3 || axis2 > 3) {
      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 TH3::GetCovariance(Int_t axis1, Int_t axis2) const
{
   // Return covariance between axis1 and axis2.

   if (axis1 < 1 || axis2 < 1 || axis1 > 3 || axis2 > 3) {
      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];
   Double_t sumwz  = stats[7];
   Double_t sumwz2 = stats[8];
   Double_t sumwxz = stats[9];
   Double_t sumwyz = stats[10];

   if (sumw == 0) return 0;
   if (axis1 == 1 && axis2 == 1) {
      return TMath::Abs(sumwx2/sumw - sumwx*sumwx/sumw2);
   }
   if (axis1 == 2 && axis2 == 2) {
      return TMath::Abs(sumwy2/sumw - sumwy*sumwy/sumw2);
   }
   if (axis1 == 3 && axis2 == 3) {
      return TMath::Abs(sumwz2/sumw - sumwz*sumwz/sumw2);
   }
   if ((axis1 == 1 && axis2 == 2) || (axis1 == 2 && axis2 == 1)) {
      return sumwxy/sumw - sumwx/sumw*sumwy/sumw;
   }
   if ((axis1 == 1 && axis2 == 3) || (axis1 == 3 && axis2 == 1)) {
      return sumwxz/sumw - sumwx/sumw*sumwz/sumw;
   }
   if ((axis1 == 2 && axis2 == 3) || (axis1 == 3 && axis2 == 2)) {
      return sumwyz/sumw - sumwy/sumw*sumwz/sumw;
   }
   return 0;
}


//______________________________________________________________________________
void TH3::GetRandom3(Double_t &x, Double_t &y, Double_t &z)
{
   // Return 3 random numbers along axis x , y and z distributed according
   // the cellcontents of a 3-dim histogram

   Int_t nbinsx = GetNbinsX();
   Int_t nbinsy = GetNbinsY();
   Int_t nbinsz = GetNbinsZ();
   Int_t nxy    = nbinsx*nbinsy;
   Int_t nbins  = nxy*nbinsz;
   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; z = 0; return;}
   // case histogram has negative bins
   if (integral == TMath::QuietNaN() ) { x = TMath::QuietNaN(); y = TMath::QuietNaN(); z = TMath::QuietNaN(); return;}

   Double_t r1 = gRandom->Rndm();
   Int_t ibin = TMath::BinarySearch(nbins,fIntegral,(Double_t) r1);
   Int_t binz = ibin/nxy;
   Int_t biny = (ibin - nxy*binz)/nbinsx;
   Int_t binx = ibin - nbinsx*(biny + nbinsy*binz);
   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();
   z = fZaxis.GetBinLowEdge(binz+1) + fZaxis.GetBinWidth(binz+1)*gRandom->Rndm();
}


//______________________________________________________________________________
void TH3::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
   // stats[7] = sumwz
   // stats[8] = sumwz2
   // stats[9] = sumwxz
   // stats[10]= sumwyz

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

   Int_t bin, binx, biny, binz;
   Double_t w,err;
   Double_t x,y,z;
   if ((fTsumw == 0 && fEntries > 0) || fXaxis.TestBit(TAxis::kAxisRange) || fYaxis.TestBit(TAxis::kAxisRange) || fZaxis.TestBit(TAxis::kAxisRange)) {
      for (bin=0;bin<9;bin++) stats[bin] = 0;

      Int_t firstBinX = fXaxis.GetFirst();
      Int_t lastBinX  = fXaxis.GetLast();
      Int_t firstBinY = fYaxis.GetFirst();
      Int_t lastBinY  = fYaxis.GetLast();
      Int_t firstBinZ = fZaxis.GetFirst();
      Int_t lastBinZ  = fZaxis.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;
         }
         if ( !fZaxis.TestBit(TAxis::kAxisRange) ) {
            if (firstBinZ == 1) firstBinZ = 0;
            if (lastBinZ ==  fZaxis.GetNbins() ) lastBinZ += 1;
         }
      }
      for (binz = firstBinZ; binz <= lastBinZ; binz++) {
         z = fZaxis.GetBinCenter(binz);
         for (biny = firstBinY; biny <= lastBinY; biny++) {
            y = fYaxis.GetBinCenter(biny);
            for (binx = firstBinX; binx <= lastBinX; binx++) {
               bin = GetBin(binx,biny,binz);
               x   = fXaxis.GetBinCenter(binx);
               //w   = TMath::Abs(GetBinContent(bin));
               w   = RetrieveBinContent(bin);
               err = TMath::Abs(GetBinError(bin));
               stats[0] += w;
               stats[1] += err*err;
               stats[2] += w*x;
               stats[3] += w*x*x;
               stats[4] += w*y;
               stats[5] += w*y*y;
               stats[6] += w*x*y;
               stats[7] += w*z;
               stats[8] += w*z*z;
               stats[9] += w*x*z;
               stats[10]+= w*y*z;
            }
         }
      }
   } else {
      stats[0] = fTsumw;
      stats[1] = fTsumw2;
      stats[2] = fTsumwx;
      stats[3] = fTsumwx2;
      stats[4] = fTsumwy;
      stats[5] = fTsumwy2;
      stats[6] = fTsumwxy;
      stats[7] = fTsumwz;
      stats[8] = fTsumwz2;
      stats[9] = fTsumwxz;
      stats[10]= fTsumwyz;
   }
}


//______________________________________________________________________________
Double_t TH3::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, y and in z.

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


//______________________________________________________________________________
Double_t TH3::Integral(Int_t binx1, Int_t binx2, Int_t biny1, Int_t biny2,
                       Int_t binz1, Int_t binz2, Option_t *option) const
{
   // Return integral of bin contents in range [binx1,binx2],[biny1,biny2],[binz1,binz2]
   // for a 3-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, y and in z.

   Double_t err = 0;
   return DoIntegral(binx1,binx2,biny1,biny2,binz1,binz2,err,option);
}


//______________________________________________________________________________
Double_t TH3::IntegralAndError(Int_t binx1, Int_t binx2, Int_t biny1, Int_t biny2,
                               Int_t binz1, Int_t binz2,
                               Double_t & error, Option_t *option) const
{
   // Return integral of bin contents in range [binx1,binx2],[biny1,biny2],[binz1,binz2]
   // for a 3-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, y and in z.

   return DoIntegral(binx1,binx2,biny1,biny2,binz1,binz2,error,option,kTRUE);
}


//______________________________________________________________________________
Double_t TH3::Interpolate(Double_t)
{
   //Not yet implemented

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


//______________________________________________________________________________
Double_t TH3::Interpolate(Double_t, Double_t)
{
   //Not yet implemented

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


//______________________________________________________________________________
Double_t TH3::Interpolate(Double_t x, Double_t y, Double_t z)
{
   // Given a point P(x,y,z), Interpolate approximates the value via trilinear interpolation
   // based on the 8 nearest bin center points ( corner of the cube surronding the points)
   // The Algorithm is described in http://en.wikipedia.org/wiki/Trilinear_interpolation
   // The given values (x,y,z) must be between first bin center and  last bin center for each coordinate:
   //
   //   fXAxis.GetBinCenter(1) < x  < fXaxis.GetBinCenter(nbinX)     AND
   //   fYAxis.GetBinCenter(1) < y  < fYaxis.GetBinCenter(nbinY)     AND
   //   fZAxis.GetBinCenter(1) < z  < fZaxis.GetBinCenter(nbinZ)

   Int_t ubx = fXaxis.FindBin(x);
   if ( x < fXaxis.GetBinCenter(ubx) ) ubx -= 1;
   Int_t obx = ubx + 1;

   Int_t uby = fYaxis.FindBin(y);
   if ( y < fYaxis.GetBinCenter(uby) ) uby -= 1;
   Int_t oby = uby + 1;

   Int_t ubz = fZaxis.FindBin(z);
   if ( z < fZaxis.GetBinCenter(ubz) ) ubz -= 1;
   Int_t obz = ubz + 1;


//    if ( IsBinUnderflow(GetBin(ubx, uby, ubz)) ||
//         IsBinOverflow (GetBin(obx, oby, obz)) ) {
   if (ubx <=0 || uby <=0 || ubz <= 0 ||
       obx > fXaxis.GetNbins() || oby > fYaxis.GetNbins() || obz > fZaxis.GetNbins() ) {
      Error("Interpolate","Cannot interpolate outside histogram domain.");
      return 0;
   }

   Double_t xw = fXaxis.GetBinCenter(obx) - fXaxis.GetBinCenter(ubx);
   Double_t yw = fYaxis.GetBinCenter(oby) - fYaxis.GetBinCenter(uby);
   Double_t zw = fZaxis.GetBinCenter(obz) - fZaxis.GetBinCenter(ubz);

   Double_t xd = (x - fXaxis.GetBinCenter(ubx)) / xw;
   Double_t yd = (y - fYaxis.GetBinCenter(uby)) / yw;
   Double_t zd = (z - fZaxis.GetBinCenter(ubz)) / zw;


   Double_t v[] = { GetBinContent( ubx, uby, ubz ), GetBinContent( ubx, uby, obz ),
                    GetBinContent( ubx, oby, ubz ), GetBinContent( ubx, oby, obz ),
                    GetBinContent( obx, uby, ubz ), GetBinContent( obx, uby, obz ),
                    GetBinContent( obx, oby, ubz ), GetBinContent( obx, oby, obz ) };


   Double_t i1 = v[0] * (1 - zd) + v[1] * zd;
   Double_t i2 = v[2] * (1 - zd) + v[3] * zd;
   Double_t j1 = v[4] * (1 - zd) + v[5] * zd;
   Double_t j2 = v[6] * (1 - zd) + v[7] * zd;


   Double_t w1 = i1 * (1 - yd) + i2 * yd;
   Double_t w2 = j1 * (1 - yd) + j2 * yd;


   Double_t result = w1 * (1 - xd) + w2 * xd;

   return result;
}


//______________________________________________________________________________
Double_t TH3::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 more than 1D the order for generating the pseudo-CDF is
   //   arbitrary, we use the pseudo-CDF's obtained from all the possible 6 combinatons of the 3 axis.
   //   The average of all the maximum  distances obtained is used in the tests.

   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();
   const TAxis *zaxis1 = h1->GetZaxis();
   const TAxis *zaxis2 = h2->GetZaxis();
   Int_t ncx1   = xaxis1->GetNbins();
   Int_t ncx2   = xaxis2->GetNbins();
   Int_t ncy1   = yaxis1->GetNbins();
   Int_t ncy2   = yaxis2->GetNbins();
   Int_t ncz1   = zaxis1->GetNbins();
   Int_t ncz2   = zaxis2->GetNbins();

   // Check consistency of dimensions
   if (h1->GetDimension() != 3 || h2->GetDimension() != 3) {
      Error("KolmogorovTest","Histograms must be 3-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;
   }
   if (ncz1 != ncz2) {
      Error("KolmogorovTest","Number of channels in Z is different, %d and %d\n",ncz1,ncz2);
      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;
   }
   diff1 = TMath::Abs(zaxis1->GetXmin() - zaxis2->GetXmin());
   diff2 = TMath::Abs(zaxis1->GetXmax() - zaxis2->GetXmax());
   if (diff1 > difprec || diff2 > difprec) {
      Error("KolmogorovTest","histograms with different binning along Z");
      return 0;
   }

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

   Int_t i,j,k,bin;
   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++) {
         for (k = kbeg; k <= kend; k++) {
            bin = h1->GetBin(i,j,k);
            sum1 += h1->GetBinContent(bin);
            sum2 += h2->GetBinContent(bin);
            Double_t ew1   = h1->GetBinError(bin);
            Double_t ew2   = h2->GetBinError(bin);
            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 Kolmogorov distance
   //   order is arbitrary take average of all possible 6 starting orders x,y,z
   int order[3] = {0,1,2};
   int binbeg[3];
   int binend[3];
   int ibin[3];
   binbeg[0] = ibeg; binbeg[1] = jbeg; binbeg[2] = kbeg;
   binend[0] = iend; binend[1] = jend; binend[2] = kend;
   Double_t vdfmax[6]; // there are in total 6 combinations
   int icomb = 0;
   Double_t s1 = 1./(6.*sum1);
   Double_t s2 = 1./(6.*sum2);
   Double_t rsum1=0, rsum2=0;
   do {
      // loop on bins
      Double_t dmax = 0;
      for (i = binbeg[order[0] ]; i <= binend[order[0] ]; i++) {
         for ( j = binbeg[order[1] ]; j <= binend[order[1] ]; j++) {
            for ( k = binbeg[order[2] ]; k <= binend[order[2] ]; k++) {
                  ibin[ order[0] ] = i;
                  ibin[ order[1] ] = j;
                  ibin[ order[2] ] = k;
                  bin = h1->GetBin(ibin[0],ibin[1],ibin[2]);
                  rsum1 += s1*h1->GetBinContent(bin);
                  rsum2 += s2*h2->GetBinContent(bin);
                  dmax   = TMath::Max(dmax, TMath::Abs(rsum1-rsum2));
            }
         }
      }
      vdfmax[icomb] = dmax;
      icomb++;
   } while (TMath::Permute(3,order)  );


   // get average of distances
   Double_t dfmax = TMath::Mean(6,vdfmax);

   //    Get Kolmogorov probability
   Double_t factnm;
   if (afunc1)      factnm = TMath::Sqrt(sum2);
   else if (afunc2) factnm = TMath::Sqrt(sum1);
   else             factnm = TMath::Sqrt(sum1*sum2/(sum1+sum2));
   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 TH3::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;
   TAxis newZAxis;
   Bool_t initialLimitsFound = kFALSE;
   Bool_t allSameLimits = kTRUE;
   Bool_t sameLimitsX = kTRUE;
   Bool_t sameLimitsY = kTRUE;
   Bool_t sameLimitsZ = kTRUE;
   Bool_t allHaveLimits = kTRUE;
   Bool_t firstHistWithLimits = kTRUE;

   TIter next(&inlist);
   TH3* 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());
              }
              if (!SameLimitsAndNBins(fZaxis, *(h->GetZaxis())) ) {
                if (h->GetZaxis()->GetXbins()->GetSize() != 0) fZaxis.Set(h->GetZaxis()->GetNbins(), h->GetZaxis()->GetXbins()->GetArray());
                else                                           fZaxis.Set(h->GetZaxis()->GetNbins(), h->GetZaxis()->GetXmin(), h->GetZaxis()->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());
            if (h->GetZaxis()->GetXbins()->GetSize() != 0) newZAxis.Set(h->GetZaxis()->GetNbins(), h->GetZaxis()->GetXbins()->GetArray());
            else                                           newZAxis.Set(h->GetZaxis()->GetNbins(), h->GetZaxis()->GetXmin(), h->GetZaxis()->GetXmax());
         }
         else {
           if(!SameLimitsAndNBins(newXAxis, *(h->GetXaxis()))) {
             sameLimitsX = kFALSE;
             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;
             }
           }
           if(!SameLimitsAndNBins(newYAxis, *(h->GetYaxis()))) {
             sameLimitsY = kFALSE;
             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;
             }
           }
           if(!SameLimitsAndNBins(newZAxis, *(h->GetZaxis()))) {
             sameLimitsZ = kFALSE;
             if (!RecomputeAxisLimits(newZAxis, *(h->GetZaxis()))) {
               Error("Merge", "Cannot merge histograms - limits are inconsistent:\n "
                     "first: (%d, %f, %f), second: (%d, %f, %f)",
                     newZAxis.GetNbins(), newZAxis.GetXmin(), newZAxis.GetXmax(),
                     h->GetZaxis()->GetNbins(), h->GetZaxis()->GetXmin(),
                     h->GetZaxis()->GetXmax());
               return -1;
             }
           }
           allSameLimits = sameLimitsX && sameLimitsY && sameLimitsZ;
         }
      }
   } while ( ( h = dynamic_cast<TH3*> ( 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
   TH3 * 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 = (TH3*)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());
     }
     if (!sameLimitsZ) {
       fZaxis.SetRange(0,0);
       if (newZAxis.GetXbins()->GetSize() != 0) fZaxis.Set(newZAxis.GetNbins(),newZAxis.GetXbins()->GetArray());
       else                                     fZaxis.Set(newZAxis.GetNbins(),newZAxis.GetXmin(), newZAxis.GetXmax());
     }
     fNcells = (fXaxis.GetNbins()+2)*(fYaxis.GetNbins()+2)*(fZaxis.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<TH3*> (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[4*i + 2], h->fBuffer[4*i + 3],
               h->fBuffer[4*i + 4], h->fBuffer[4*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, binz, ix, iy, iz, nx, ny, nz, bin, ibin;
   Double_t cu;
   Int_t nbix = fXaxis.GetNbins();
   Int_t nbiy = fYaxis.GetNbins();
   Bool_t canExtend = CanExtendAllAxes();
   SetCanExtend(TH1::kNoAxis); // reset, otherwise setting the under/overflow will extend the axis

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

      // skip empty histograms
      Double_t histEntries = h->GetEntries();
      if (h->fTsumw == 0 && h->GetEntries() == 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();
         nz = h->GetZaxis()->GetNbins();

         // mantain loop in separate binz, biny and binz to avoid
         // callinig FindBin(x,y,z) for every bin
         for (binz = 0; binz <= nz + 1; binz++) {
            if (!allSameLimits)
               iz = fZaxis.FindBin(h->GetZaxis()->GetBinCenter(binz));
            else
               iz = binz;
            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 + (ny+2)*binz);
                  cu  = h->RetrieveBinContent(bin);
                  if (!allSameLimits) {
                     // look at non-empty unerflow/overflows
                     if (cu != 0 && ( (!sameLimitsX && (binx == 0 || binx == nx+1)) || (!sameLimitsY && (biny == 0 || biny == ny+1)) || (!sameLimitsZ && (binz == 0 || binz == nz+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 have same limits
                     ix = binx;
                  }

                  ibin = ix +(nbix+2)*(iy + (nbiy+2)*iz);
                  if (ibin <0) continue;
                  AddBinContent(ibin,cu);
                  if (fSumw2.fN) {
                     Double_t error1 = h->GetBinError(bin);
                     fSumw2.fArray[ibin] += error1*error1;
                  }
               }
            }
         }
      }
   }
   if (canExtend) SetCanExtend(TH1::kAllAxes);

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


//______________________________________________________________________________
TH1D *TH3::ProjectionX(const char *name, Int_t iymin, Int_t iymax,
                       Int_t izmin, Int_t izmax, Option_t *option) const
{
   // Project a 3-D histogram into a 1-D histogram along X.
   //
   //   The projection is always of the type TH1D.
   //   The projection is made from the cells along the X axis
   //   ranging from iymin to iymax and izmin to izmax included.
   //   By default, underflow and overflows are included in both the Y and Z axis.
   //   By Setting iymin=1 and iymax=NbinsY the underflow and/or overflow in Y will be excluded
   //   By setting izmin=1 and izmax=NbinsZ the underflow and/or overflow in Z will be excluded
   //
   //   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 target axes will be
   //   kept, but only bins inside the selected range will be filled.
   //
   //   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 TH3.
   //
   //  implemented using Project3D

   // in case of default name append the parent name
   TString hname = name;
   if (hname == "_px") hname = TString::Format("%s%s", GetName(), name);
   TString title =  TString::Format("%s ( Projection X )",GetTitle());

   return DoProject1D(hname, title, iymin, iymax, izmin, izmax, &fXaxis, &fYaxis, &fZaxis, option);
}


//______________________________________________________________________________
TH1D *TH3::ProjectionY(const char *name, Int_t ixmin, Int_t ixmax,
                       Int_t izmin, Int_t izmax, Option_t *option) const
{
   // Project a 3-D histogram into a 1-D histogram along Y.
   //
   //   The projection is always of the type TH1D.
   //   The projection is made from the cells along the Y axis
   //   ranging from ixmin to ixmax and izmin to izmax included.
   //   By default, underflow and overflow are included in both the X and Z axis.
   //   By setting ixmin=1 and ixmax=NbinsX the underflow and/or overflow in X will be excluded
   //   By setting izmin=1 and izmax=NbinsZ the underflow and/or overflow in Z will be excluded
   //
   //   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 target axes will be
   //   kept, but only bins inside the selected range will be filled.
   //
   //   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 TH3.
   //
   //  implemented using Project3D

   TString hname = name;
   if (hname == "_py") hname = TString::Format("%s%s", GetName(), name);
   TString title =  TString::Format("%s ( Projection Y )",GetTitle());

   return DoProject1D(hname, title, ixmin, ixmax, izmin, izmax, &fYaxis, &fXaxis, &fZaxis, option);
}

//______________________________________________________________________________
TH1D *TH3::ProjectionZ(const char *name, Int_t ixmin, Int_t ixmax,
                       Int_t iymin, Int_t iymax, Option_t *option) const
{
   // Project a 3-D histogram into a 1-D histogram along Z.
   //
   //   The projection is always of the type TH1D.
   //   The projection is made from the cells along the Z axis
   //   ranging from ixmin to ixmax and iymin to iymax included.
   //   By default, bins 1 to nx and 1 to ny  are included
   //   By default, underflow and overflow are included in both the X and Y axis.
   //   By Setting ixmin=1 and ixmax=NbinsX the underflow and/or overflow in X will be excluded
   //   By setting iymin=1 and/or iymax=NbinsY the underflow and/or overflow in Y will be excluded
   //
   //   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 target axes will be
   //   kept, but only bins inside the selected range will be filled.
   //
   //   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 TH3.
   //
   //  implemented using Project3D


   TString hname = name;
   if (hname == "_pz") hname = TString::Format("%s%s", GetName(), name);
   TString title =  TString::Format("%s ( Projection Z )",GetTitle());

   return DoProject1D(hname, title, ixmin, ixmax, iymin, iymax, &fZaxis, &fXaxis, &fYaxis, option);
}


//______________________________________________________________________________
TH1D *TH3::DoProject1D(const char* name, const char * title, int imin1, int imax1, int imin2, int imax2, 
                       const TAxis* projAxis, const TAxis * axis1, const TAxis * axis2, Option_t * option) const 
{
   // internal methdod performing the projection to 1D histogram
   // called from TH3::Project3D


   TString opt = option;
   opt.ToLower();

   Int_t iminOld1 = axis1->GetFirst();
   Int_t imaxOld1 = axis1->GetLast();
   Int_t iminOld2 = axis2->GetFirst();
   Int_t imaxOld2 = axis2->GetLast();

   // need to cast-away constness to set range 
   const_cast<TAxis*>(axis1)->SetRange(imin1,imax1);
   const_cast<TAxis*>(axis2)->SetRange(imin2,imax2);

   Bool_t computeErrors = GetSumw2N();
   if (opt.Contains("e") ) {
      computeErrors = kTRUE;
      opt.Remove(opt.First("e"),1);
   }
   Bool_t originalRange = kFALSE;
   if (opt.Contains('o') ) {
      originalRange = kTRUE;
      opt.Remove(opt.First("o"),1);
   }

   TH1D * h1 = DoProject1D(name, title, projAxis, computeErrors, originalRange,true,true);

   // restore original range
   if (axis1->TestBit(TAxis::kAxisRange)) const_cast<TAxis*>(axis1)->SetRange(iminOld1,imaxOld1);
   if (axis2->TestBit(TAxis::kAxisRange)) const_cast<TAxis*>(axis2)->SetRange(iminOld2,imaxOld2);

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

   return h1;
}

TH1D *TH3::DoProject1D(const char* name, const char * title, const TAxis* projX,
                       bool computeErrors, bool originalRange,
                       bool useUF, bool useOF) const
{
   // internal methdod performing the projection to 1D histogram
   // called from other TH3::DoProject1D 


   // Create the projection histogram
   TH1D *h1 = 0;

   // Get range to use as well as bin limits
   Int_t ixmin = projX->GetFirst();
   Int_t ixmax = projX->GetLast();
//   if (ixmin == 0 && ixmax == 0) { ixmin = 1; ixmax = projX->GetNbins(); }
   Int_t nx = ixmax-ixmin+1;

   // Create the histogram, either reseting a preexisting one
   TObject *h1obj = gROOT->FindObject(name);
   if (h1obj && h1obj->InheritsFrom(TH1::Class())) {
      if (h1obj->IsA() != TH1D::Class() ) {
         Error("DoProject1D","Histogram with name %s must be a TH1D and is a %s",name,h1obj->ClassName());
         return 0;
      }
      h1 = (TH1D*)h1obj;
      // reset histogram and re-set the axis in any case
      h1->Reset();
      const TArrayD *bins = projX->GetXbins();
      if ( originalRange )
      {
         if (bins->fN == 0) {
            h1->SetBins(projX->GetNbins(),projX->GetXmin(),projX->GetXmax());
         } else {
            h1->SetBins(projX->GetNbins(),bins->fArray);
         }
      } else {
         if (bins->fN == 0) {
            h1->SetBins(nx,projX->GetBinLowEdge(ixmin),projX->GetBinUpEdge(ixmax));
         } else {
            h1->SetBins(nx,&bins->fArray[ixmin-1]);
         }
      }
   }

   if (!h1) {
      const TArrayD *bins = projX->GetXbins();
      if ( originalRange )
      {
         if (bins->fN == 0) {
            h1 = new TH1D(name,title,projX->GetNbins(),projX->GetXmin(),projX->GetXmax());
         } else {
            h1 = new TH1D(name,title,projX->GetNbins(),bins->fArray);
         }
      } else {
         if (bins->fN == 0) {
            h1 = new TH1D(name,title,nx,projX->GetBinLowEdge(ixmin),projX->GetBinUpEdge(ixmax));
         } else {
            h1 = new TH1D(name,title,nx,&bins->fArray[ixmin-1]);
         }
      }
   }

   // Copy the axis attributes and the axis labels if needed.
   h1->GetXaxis()->ImportAttributes(projX);
   THashList* labels = projX->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());

   // Activate errors
   if ( computeErrors ) h1->Sumw2();

   // Set references to the axis, so that the bucle has no branches.
   const TAxis* out1 = 0;
   const TAxis* out2 = 0;
   if ( projX == GetXaxis() ) {
      out1 = GetYaxis();
      out2 = GetZaxis();
   } else if ( projX == GetYaxis() ) {
      out1 = GetZaxis();
      out2 = GetXaxis();
   } else {
      out1 = GetYaxis();
      out2 = GetXaxis();
   }

   Int_t *refX = 0, *refY = 0, *refZ = 0;
   Int_t ixbin, out1bin, out2bin;
   if ( projX == GetXaxis() ) { refX = &ixbin;   refY = &out1bin; refZ = &out2bin; }
   if ( projX == GetYaxis() ) { refX = &out2bin; refY = &ixbin;   refZ = &out1bin; }
   if ( projX == GetZaxis() ) { refX = &out2bin; refY = &out1bin; refZ = &ixbin;   }
   R__ASSERT (refX != 0 && refY != 0 && refZ != 0);

   // Fill the projected histogram excluding underflow/overflows if considered in the option
   // if specified in the option (by default they considered)
   Double_t totcont  = 0;

   Int_t out1min = out1->GetFirst();
   Int_t out1max = out1->GetLast();
   // GetFirst(), GetLast() can return (0,0) when the range bit is set artifically (see TAxis::SetRange)
 //if (out1min == 0 && out1max == 0) { out1min = 1; out1max = out1->GetNbins(); }
   // correct for underflow/overflows
   if (useUF && !out1->TestBit(TAxis::kAxisRange) )  out1min -= 1;
   if (useOF && !out1->TestBit(TAxis::kAxisRange) )  out1max += 1;
   Int_t out2min = out2->GetFirst();
   Int_t out2max = out2->GetLast();
//   if (out2min == 0 && out2max == 0) { out2min = 1; out2max = out2->GetNbins(); }
   if (useUF && !out2->TestBit(TAxis::kAxisRange) )  out2min -= 1;
   if (useOF && !out2->TestBit(TAxis::kAxisRange) )  out2max += 1;

   for (ixbin=0;ixbin<=1+projX->GetNbins();ixbin++) {
      if ( projX->TestBit(TAxis::kAxisRange) && ( ixbin < ixmin || ixbin > ixmax )) continue;

      Double_t cont = 0;
      Double_t err2 = 0;

      // loop on the bins to be integrated (outbin should be called inbin)
      for (out1bin = out1min; out1bin <= out1max; out1bin++) {
         for (out2bin = out2min; out2bin <= out2max; out2bin++) {

            Int_t bin = GetBin(*refX, *refY, *refZ);

            // sum the bin contents and errors if needed
            cont += RetrieveBinContent(bin);
            if (computeErrors) {
               Double_t exyz = GetBinError(bin);
               err2 += exyz*exyz;
            }
         }
      }
      Int_t ix    = h1->FindBin( projX->GetBinCenter(ixbin) );
      h1->SetBinContent(ix ,cont);
      if (computeErrors) h1->SetBinError(ix, TMath::Sqrt(err2) );
      // sum all content
      totcont += cont;

   }

   // since we use a combination of fill and SetBinError we need to reset and recalculate the statistics
   // for weighted histograms otherwise sumw2 will be wrong.
   // We  can keep the original statistics from the TH3 if the projected sumw is consistent with original one
   // i.e. when no events are thrown away
   bool resetStats = true;
   double eps = 1.E-12;
   if (IsA() == TH3F::Class() ) eps = 1.E-6;
   if (fTsumw != 0 && TMath::Abs( fTsumw - totcont) <  TMath::Abs(fTsumw) * eps) resetStats = false;

   bool resetEntries = resetStats;
   // entries are calculated using underflow/overflow. If excluded entries must be reset
   resetEntries |= !useUF || !useOF;


   if (!resetStats) {
      Double_t stats[kNstat];
      GetStats(stats);
      if ( projX == GetYaxis() ) {
         stats[2] = stats[4];
         stats[3] = stats[5];
      }
      else if  ( projX == GetZaxis() ) {
         stats[2] = stats[7];
         stats[3] = stats[8];
      }
      h1->PutStats(stats);
   }
   else {
      // reset statistics
      h1->ResetStats();
   }
   if (resetEntries) {
      // 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 (computeErrors) entries = h1->GetEffectiveEntries();
      h1->SetEntries( entries );
   }
   else {
      h1->SetEntries( fEntries );
   }

   return h1;
}


//______________________________________________________________________________
TH2D *TH3::DoProject2D(const char* name, const char * title, const TAxis* projX, const TAxis* projY,
                    bool computeErrors, bool originalRange,
                    bool useUF, bool useOF) const
{
   // internal method performing the projection to a 2D histogram
   // called from TH3::Project3D

   TH2D *h2 = 0;

   // Get range to use as well as bin limits
   Int_t ixmin = projX->GetFirst();
   Int_t ixmax = projX->GetLast();
   Int_t iymin = projY->GetFirst();
   Int_t iymax = projY->GetLast();
   if (ixmin == 0 && ixmax == 0) { ixmin = 1; ixmax = projX->GetNbins(); }
   if (iymin == 0 && iymax == 0) { iymin = 1; iymax = projY->GetNbins(); }
   Int_t nx = ixmax-ixmin+1;
   Int_t ny = iymax-iymin+1;

   // Create the histogram, either reseting a preexisting one
   //  or creating one from scratch.
   // Does an object with the same name exists?
   TObject *h2obj = gROOT->FindObject(name);
   if (h2obj && h2obj->InheritsFrom(TH1::Class())) {
      if ( h2obj->IsA() != TH2D::Class() ) {
         Error("DoProject2D","Histogram with name %s must be a TH2D and is a %s",name,h2obj->ClassName());
         return 0;
      }
      h2 = (TH2D*)h2obj;
      // reset histogram and its axes
      h2->Reset();
      const TArrayD *xbins = projX->GetXbins();
      const TArrayD *ybins = projY->GetXbins();
      if ( originalRange ) {
         h2->SetBins(projY->GetNbins(),projY->GetXmin(),projY->GetXmax()
                     ,projX->GetNbins(),projX->GetXmin(),projX->GetXmax());
         // set bins for mixed axis do not exists - need to set afterwards the variable bins
         if (ybins->fN != 0)
            h2->GetXaxis()->Set(projY->GetNbins(),&ybins->fArray[iymin-1]);
         if (xbins->fN != 0)
            h2->GetYaxis()->Set(projX->GetNbins(),&xbins->fArray[ixmin-1]);
      } else {
         h2->SetBins(ny,projY->GetBinLowEdge(iymin),projY->GetBinUpEdge(iymax)
                     ,nx,projX->GetBinLowEdge(ixmin),projX->GetBinUpEdge(ixmax));
         if (ybins->fN != 0)
            h2->GetXaxis()->Set(ny,&ybins->fArray[iymin-1]);
         if (xbins->fN != 0)
            h2->GetYaxis()->Set(nx,&xbins->fArray[ixmin-1]);
      }
   }


   if (!h2) {
      const TArrayD *xbins = projX->GetXbins();
      const TArrayD *ybins = projY->GetXbins();
      if ( originalRange )
      {
         if (xbins->fN == 0 && ybins->fN == 0) {
            h2 = new TH2D(name,title,projY->GetNbins(),projY->GetXmin(),projY->GetXmax()
                          ,projX->GetNbins(),projX->GetXmin(),projX->GetXmax());
         } else if (ybins->fN == 0) {
            h2 = new TH2D(name,title,projY->GetNbins(),projY->GetXmin(),projY->GetXmax()
                          ,projX->GetNbins(),&xbins->fArray[ixmin-1]);
         } else if (xbins->fN == 0) {
            h2 = new TH2D(name,title,projY->GetNbins(),&ybins->fArray[iymin-1]
                          ,projX->GetNbins(),projX->GetXmin(),projX->GetXmax());
         } else {
            h2 = new TH2D(name,title,projY->GetNbins(),&ybins->fArray[iymin-1],projX->GetNbins(),&xbins->fArray[ixmin-1]);
         }
      } else {
         if (xbins->fN == 0 && ybins->fN == 0) {
            h2 = new TH2D(name,title,ny,projY->GetBinLowEdge(iymin),projY->GetBinUpEdge(iymax)
                          ,nx,projX->GetBinLowEdge(ixmin),projX->GetBinUpEdge(ixmax));
         } else if (ybins->fN == 0) {
            h2 = new TH2D(name,title,ny,projY->GetBinLowEdge(iymin),projY->GetBinUpEdge(iymax)
                          ,nx,&xbins->fArray[ixmin-1]);
         } else if (xbins->fN == 0) {
            h2 = new TH2D(name,title,ny,&ybins->fArray[iymin-1]
                          ,nx,projX->GetBinLowEdge(ixmin),projX->GetBinUpEdge(ixmax));
         } else {
            h2 = new TH2D(name,title,ny,&ybins->fArray[iymin-1],nx,&xbins->fArray[ixmin-1]);
         }
      }
   }

   // Copy the axis attributes and the axis labels if needed.
   THashList* labels1 = 0;
   THashList* labels2 = 0;
   // "xy"
   h2->GetXaxis()->ImportAttributes(projY);
   h2->GetYaxis()->ImportAttributes(projX);
   labels1 = projY->GetLabels();
   labels2 = projX->GetLabels();
   if (labels1) {
      TIter iL(labels1);
      TObjString* lb;
      Int_t i = 1;
      while ((lb=(TObjString*)iL())) {
         h2->GetXaxis()->SetBinLabel(i,lb->String().Data());
         i++;
      }
   }
   if (labels2) {
      TIter iL(labels2);
      TObjString* lb;
      Int_t i = 1;
      while ((lb=(TObjString*)iL())) {
         h2->GetYaxis()->SetBinLabel(i,lb->String().Data());
         i++;
      }
   }
   h2->SetLineColor(this->GetLineColor());
   h2->SetFillColor(this->GetFillColor());
   h2->SetMarkerColor(this->GetMarkerColor());
   h2->SetMarkerStyle(this->GetMarkerStyle());

   // Activate errors
   if ( computeErrors) h2->Sumw2();

   // Set references to the axis, so that the bucle has no branches.
   const TAxis* out = 0;
   if ( projX != GetXaxis() && projY != GetXaxis() ) {
      out = GetXaxis();
   } else if ( projX != GetYaxis() && projY != GetYaxis() ) {
      out = GetYaxis();
   } else {
      out = GetZaxis();
   }

   Int_t *refX = 0, *refY = 0, *refZ = 0;
   Int_t ixbin, iybin, outbin;
   if ( projX == GetXaxis() && projY == GetYaxis() ) { refX = &ixbin;  refY = &iybin;  refZ = &outbin; }
   if ( projX == GetYaxis() && projY == GetXaxis() ) { refX = &iybin;  refY = &ixbin;  refZ = &outbin; }
   if ( projX == GetXaxis() && projY == GetZaxis() ) { refX = &ixbin;  refY = &outbin; refZ = &iybin;  }
   if ( projX == GetZaxis() && projY == GetXaxis() ) { refX = &iybin;  refY = &outbin; refZ = &ixbin;  }
   if ( projX == GetYaxis() && projY == GetZaxis() ) { refX = &outbin; refY = &ixbin;  refZ = &iybin;  }
   if ( projX == GetZaxis() && projY == GetYaxis() ) { refX = &outbin; refY = &iybin;  refZ = &ixbin;  }
   R__ASSERT (refX != 0 && refY != 0 && refZ != 0);

   // Fill the projected histogram excluding underflow/overflows if considered in the option
   // if specified in the option (by default they considered)
   Double_t totcont  = 0;

   Int_t outmin = out->GetFirst();
   Int_t outmax = out->GetLast();
   // GetFirst(), GetLast() can return (0,0) when the range bit is set artifically (see TAxis::SetRange)
   if (outmin == 0 && outmax == 0) { outmin = 1; outmax = out->GetNbins(); }
   // correct for underflow/overflows
   if (useUF && !out->TestBit(TAxis::kAxisRange) )  outmin -= 1;
   if (useOF && !out->TestBit(TAxis::kAxisRange) )  outmax += 1;

   for (ixbin=0;ixbin<=1+projX->GetNbins();ixbin++) {
      if ( projX->TestBit(TAxis::kAxisRange) && ( ixbin < ixmin || ixbin > ixmax )) continue;
      Int_t ix = h2->GetYaxis()->FindBin( projX->GetBinCenter(ixbin) );

      for (iybin=0;iybin<=1+projY->GetNbins();iybin++) {
         if ( projY->TestBit(TAxis::kAxisRange) && ( iybin < iymin || iybin > iymax )) continue;
         Int_t iy = h2->GetXaxis()->FindBin( projY->GetBinCenter(iybin) );

         Double_t cont = 0;
         Double_t err2 = 0;

         // loop on the bins to be integrated (outbin should be called inbin)
         for (outbin = outmin; outbin <= outmax; outbin++) {

            Int_t bin = GetBin(*refX,*refY,*refZ);

            // sum the bin contents and errors if needed
            cont += RetrieveBinContent(bin);
            if (computeErrors) {
               Double_t exyz = GetBinError(bin);
               err2 += exyz*exyz;
            }

         }

         // remember axis are inverted
         h2->SetBinContent(iy , ix, cont);
         if (computeErrors) h2->SetBinError(iy, ix, TMath::Sqrt(err2) );
         // sum all content
         totcont += cont;

      }
   }

   // since we use fill we need to reset and recalculate the statistics (see comment in DoProject1D )
   // or keep original statistics if consistent sumw2
   bool resetStats = true;
   double eps = 1.E-12;
   if (IsA() == TH3F::Class() ) eps = 1.E-6;
   if (fTsumw != 0 && TMath::Abs( fTsumw - totcont) <  TMath::Abs(fTsumw) * eps) resetStats = false;

   bool resetEntries = resetStats;
   // entries are calculated using underflow/overflow. If excluded entries must be reset
   resetEntries |= !useUF || !useOF;

   if (!resetStats) {
      Double_t stats[kNstat];
      Double_t oldst[kNstat]; // old statistics
      for (Int_t i = 0; i < kNstat; ++i) { oldst[i] = 0; }
      GetStats(oldst);
      std::copy(oldst,oldst+kNstat,stats);
      // not that projX refer to Y axis and projX refer to the X axis of projected histogram
      // nothing to do for projection in Y vs X
      if ( projY == GetXaxis() && projX == GetZaxis() ) {  // case XZ
         stats[4] = oldst[7];
         stats[5] = oldst[8];
         stats[6] = oldst[9];
      }
      if ( projY == GetYaxis() ) {
         stats[2] = oldst[4];
         stats[3] = oldst[5];
         if ( projX == GetXaxis() )  { // case YX
            stats[4] = oldst[2];
            stats[5] = oldst[3];
         }
         if ( projX == GetZaxis() )  { // case YZ
            stats[4] = oldst[7];
            stats[5] = oldst[8];
            stats[6] = oldst[10];
         }
      }
      else if  ( projY == GetZaxis() ) {
         stats[2] = oldst[7];
         stats[3] = oldst[8];
         if ( projX == GetXaxis() )  { // case ZX
            stats[4] = oldst[2];
            stats[5] = oldst[3];
            stats[6] = oldst[9];
         }
         if ( projX == GetYaxis() )  { // case ZY
            stats[4] = oldst[4];
            stats[5] = oldst[5];
            stats[6] = oldst[10];
         }
      }
      // set the new statistics
      h2->PutStats(stats);
   }
   else {
      // recalculate the statistics
      h2->ResetStats();
   }

   if (resetEntries) {
      // use the effective entries for the entries
      // since this  is the only way to estimate them
      Double_t entries =  h2->GetEffectiveEntries();
      if (!computeErrors) entries = TMath::Floor( entries + 0.5); // to avoid numerical rounding
      h2->SetEntries( entries );
   }
   else {
      h2->SetEntries( fEntries );
   }


   return h2;
}


//______________________________________________________________________________
TH1 *TH3::Project3D(Option_t *option) const
{
   // Project a 3-d histogram into 1 or 2-d histograms depending on the
   // option parameter
   // option may contain a combination of the characters x,y,z,e
   // option = "x" return the x projection into a TH1D histogram
   // option = "y" return the y projection into a TH1D histogram
   // option = "z" return the z projection into a TH1D histogram
   // option = "xy" return the x versus y projection into a TH2D histogram
   // option = "yx" return the y versus x projection into a TH2D histogram
   // option = "xz" return the x versus z projection into a TH2D histogram
   // option = "zx" return the z versus x projection into a TH2D histogram
   // option = "yz" return the y versus z projection into a TH2D histogram
   // option = "zy" return the z versus y projection into a TH2D histogram
   // NB: the notation "a vs b" means "a" vertical and "b" horizontal
   //
   // option = "o" original axis range of the target axes will be
   //   kept, but only bins inside the selected range will be filled.
   //
   // If option contains the string "e", errors are computed
   //
   // The projection is made for the selected bins only.
   // To select a bin range along an axis, use TAxis::SetRange, eg
   //    h3.GetYaxis()->SetRange(23,56);
   //
   // NOTE 1: The generated histogram is named th3name + option
   // eg if the TH3* h histogram is named "myhist", then
   // h->Project3D("xy"); produces a TH2D histogram named "myhist_xy"
   // if a histogram of the same type already exists, it is overwritten.
   // The following sequence
   //    h->Project3D("xy");
   //    h->Project3D("xy2");
   //  will generate two TH2D histograms named "myhist_xy" and "myhist_xy2"
   //  A different name can be generated by attaching a string to the option
   //  For example h->Project3D("name_xy") will generate an histogram with the name:  h3dname_name_xy.
   //
   //  NOTE 2: If an histogram of the same type already exists,
   //  the histogram is reset and filled again with the projected contents of the TH3.
   //
   //  NOTE 3: The number of entries in the projected histogram is estimated from the number of
   //  effective entries for all the cells included in the projection.
   //
   //  NOTE 4: underflow/overflow are included by default in the projection
   //  To exclude underflow and/or overflow (for both axis in case of a projection to a 1D histogram) use option "NUF" and/or "NOF"
   //  With SetRange() you can have all bins except underflow/overflow only if you set the axis bit range as
   //  following after having called SetRange:  axis->SetRange(1, axis->GetNbins());

   TString opt = option; opt.ToLower();
   Int_t pcase = 0;
   TString ptype;
   if (opt.Contains("x"))  { pcase = 1; ptype = "x"; }
   if (opt.Contains("y"))  { pcase = 2; ptype = "y"; }
   if (opt.Contains("z"))  { pcase = 3; ptype = "z"; }
   if (opt.Contains("xy")) { pcase = 4; ptype = "xy"; }
   if (opt.Contains("yx")) { pcase = 5; ptype = "yx"; }
   if (opt.Contains("xz")) { pcase = 6; ptype = "xz"; }
   if (opt.Contains("zx")) { pcase = 7; ptype = "zx"; }
   if (opt.Contains("yz")) { pcase = 8; ptype = "yz"; }
   if (opt.Contains("zy")) { pcase = 9; ptype = "zy"; }

   if (pcase == 0) {
      Error("Project3D","No projection axis specified - return a NULL pointer");
      return 0;
   }
   // do not remove ptype from opt to use later in the projected histo name

   Bool_t computeErrors = GetSumw2N();
   if (opt.Contains("e") ) {
      computeErrors = kTRUE;
      opt.Remove(opt.First("e"),1);
   }

   Bool_t useUF = kTRUE;
   Bool_t useOF = kTRUE;
   if (opt.Contains("nuf") ) {
      useUF = kFALSE;
      opt.Remove(opt.Index("nuf"),3);
   }
   if (opt.Contains("nof") ) {
      useOF = kFALSE;
      opt.Remove(opt.Index("nof"),3);
   }

   Bool_t originalRange = kFALSE;
   if (opt.Contains('o') ) {
      originalRange = kTRUE;
      opt.Remove(opt.First("o"),1);
   }


   // Create the projection histogram
   TH1 *h = 0;

   TString name = GetName();
   TString title = GetTitle();
   name  += "_";   name  += opt;  // opt may include a user defined name
   title += " ";   title += ptype; title += " projection";

   switch (pcase) {
      case 1:
         // "x"
         h = DoProject1D(name, title, this->GetXaxis(),
                       computeErrors, originalRange, useUF, useOF);
         break;

      case 2:
         // "y"
         h = DoProject1D(name, title, this->GetYaxis(),
                       computeErrors, originalRange, useUF, useOF);
         break;

      case 3:
         // "z"
         h = DoProject1D(name, title, this->GetZaxis(),
                       computeErrors, originalRange, useUF, useOF);
         break;

      case 4:
         // "xy"
         h = DoProject2D(name, title, this->GetXaxis(),this->GetYaxis(),
                       computeErrors, originalRange, useUF, useOF);
         break;

      case 5:
         // "yx"
         h = DoProject2D(name, title, this->GetYaxis(),this->GetXaxis(),
                       computeErrors, originalRange, useUF, useOF);
         break;

      case 6:
         // "xz"
         h = DoProject2D(name, title, this->GetXaxis(),this->GetZaxis(),
                       computeErrors, originalRange, useUF, useOF);
         break;

      case 7:
         // "zx"
         h = DoProject2D(name, title, this->GetZaxis(),this->GetXaxis(),
                       computeErrors, originalRange, useUF, useOF);
         break;

      case 8:
         // "yz"
         h = DoProject2D(name, title, this->GetYaxis(),this->GetZaxis(),
                       computeErrors, originalRange, useUF, useOF);
         break;

      case 9:
         // "zy"
         h = DoProject2D(name, title, this->GetZaxis(),this->GetYaxis(),
                       computeErrors, originalRange, useUF, useOF);
         break;

   }

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

   return h;
}


//______________________________________________________________________________
void TH3::DoFillProfileProjection(TProfile2D * p2,
                                  const TAxis & a1, const TAxis & a2, const TAxis & a3,
                                  Int_t bin1, Int_t bin2, Int_t bin3,
                                  Int_t inBin, Bool_t useWeights ) const {
   // internal function to fill the bins of the projected profile 2D histogram
   // called from DoProjectProfile2D

   Double_t cont = GetBinContent(inBin);
   if (!cont) return;
   TArrayD & binSumw2 = *(p2->GetBinSumw2());
   if (useWeights && binSumw2.fN <= 0) useWeights = false;   
   if (!useWeights) p2->SetBit(TH1::kIsNotW);  // to use Fill for setting the bin contents of the Profile
   // the following fill update wrongly the fBinSumw2- need to save it before
   Double_t u = a1.GetBinCenter(bin1);
   Double_t v = a2.GetBinCenter(bin2);
   Double_t w = a3.GetBinCenter(bin3);
   Int_t outBin = p2->FindBin(u, v);
   if (outBin <0) return;
   Double_t tmp = 0;
   if ( useWeights ) tmp = binSumw2.fArray[outBin];
   p2->Fill( u , v, w, cont);
   if (useWeights ) binSumw2.fArray[outBin] = tmp + fSumw2.fArray[inBin];
}


//______________________________________________________________________________
TProfile2D *TH3::DoProjectProfile2D(const char* name, const char * title, const TAxis* projX, const TAxis* projY,
                                          bool originalRange, bool useUF, bool useOF) const
{
   // internal method to project to a 2D Profile
   // called from TH3::Project3DProfile

   // Get the ranges where we will work.
   Int_t ixmin = projX->GetFirst();
   Int_t ixmax = projX->GetLast();
   Int_t iymin = projY->GetFirst();
   Int_t iymax = projY->GetLast();
   if (ixmin == 0 && ixmax == 0) { ixmin = 1; ixmax = projX->GetNbins(); }
   if (iymin == 0 && iymax == 0) { iymin = 1; iymax = projY->GetNbins(); }
   Int_t nx = ixmax-ixmin+1;
   Int_t ny = iymax-iymin+1;

   // Create the projected profiles
   TProfile2D *p2 = 0;

   // Create the histogram, either reseting a preexisting one
   // Does an object with the same name exists?
   TObject *p2obj = gROOT->FindObject(name);
   if (p2obj && p2obj->InheritsFrom(TH1::Class())) {
      if (p2obj->IsA() != TProfile2D::Class() ) {
         Error("DoProjectProfile2D","Histogram with name %s must be a TProfile2D and is a %s",name,p2obj->ClassName());
         return 0;
      }
      p2 = (TProfile2D*)p2obj;
      // reset existing profile and re-set bins
      p2->Reset();
      const TArrayD *xbins = projX->GetXbins();
      const TArrayD *ybins = projY->GetXbins();
      if ( originalRange ) {
         p2->SetBins(projY->GetNbins(),projY->GetXmin(),projY->GetXmax()
                     ,projX->GetNbins(),projX->GetXmin(),projX->GetXmax());
         // set bins for mixed axis do not exists - need to set afterwards the variable bins
         if (ybins->fN != 0)
            p2->GetXaxis()->Set(projY->GetNbins(),&ybins->fArray[iymin-1]);
         if (xbins->fN != 0)
            p2->GetYaxis()->Set(projX->GetNbins(),&xbins->fArray[ixmin-1]);
      } else {
         p2->SetBins(ny,projY->GetBinLowEdge(iymin),projY->GetBinUpEdge(iymax)
                     ,nx,projX->GetBinLowEdge(ixmin),projX->GetBinUpEdge(ixmax));
         if (ybins->fN != 0)
            p2->GetXaxis()->Set(ny,&ybins->fArray[iymin-1]);
         if (xbins->fN != 0)
            p2->GetYaxis()->Set(nx,&xbins->fArray[ixmin-1]);
      }
   }

   if (!p2) {
      const TArrayD *xbins = projX->GetXbins();
      const TArrayD *ybins = projY->GetXbins();
      if ( originalRange ) {
         if (xbins->fN == 0 && ybins->fN == 0) {
            p2 = new TProfile2D(name,title,projY->GetNbins(),projY->GetXmin(),projY->GetXmax()
                                ,projX->GetNbins(),projX->GetXmin(),projX->GetXmax());
         } else if (ybins->fN == 0) {
            p2 = new TProfile2D(name,title,projY->GetNbins(),projY->GetXmin(),projY->GetXmax()
                                ,projX->GetNbins(),&xbins->fArray[ixmin-1]);
         } else if (xbins->fN == 0) {
            p2 = new TProfile2D(name,title,projY->GetNbins(),&ybins->fArray[iymin-1]
                                ,projX->GetNbins(),projX->GetXmin(),projX->GetXmax());
         } else {
            p2 = new TProfile2D(name,title,projY->GetNbins(),&ybins->fArray[iymin-1],projX->GetNbins(),&xbins->fArray[ixmin-1]);
         }
      } else {
         if (xbins->fN == 0 && ybins->fN == 0) {
            p2 = new TProfile2D(name,title,ny,projY->GetBinLowEdge(iymin),projY->GetBinUpEdge(iymax)
                                ,nx,projX->GetBinLowEdge(ixmin),projX->GetBinUpEdge(ixmax));
         } else if (ybins->fN == 0) {
            p2 = new TProfile2D(name,title,ny,projY->GetBinLowEdge(iymin),projY->GetBinUpEdge(iymax)
                                ,nx,&xbins->fArray[ixmin-1]);
         } else if (xbins->fN == 0) {
            p2 = new TProfile2D(name,title,ny,&ybins->fArray[iymin-1]
                                ,nx,projX->GetBinLowEdge(ixmin),projX->GetBinUpEdge(ixmax));
         } else {
            p2 = new TProfile2D(name,title,ny,&ybins->fArray[iymin-1],nx,&xbins->fArray[ixmin-1]);
         }
      }
   }

   // Set references to the axis, so that the loop has no branches.
   const TAxis* outAxis = 0;
   if ( projX != GetXaxis() && projY != GetXaxis() ) {
      outAxis = GetXaxis();
   } else if ( projX != GetYaxis() && projY != GetYaxis() ) {
      outAxis = GetYaxis();
   } else {
      outAxis = GetZaxis();
   }

   // Weights management
   bool useWeights = (GetSumw2N() > 0);
   if (useWeights ) p2->Sumw2(); // store sum of w2 in profile if histo is weighted

   // Set references to the bins, so that the loop has no branches.
   Int_t *refX = 0, *refY = 0, *refZ = 0;
   Int_t ixbin, iybin, outbin;
   if ( projX == GetXaxis() && projY == GetYaxis() ) { refX = &ixbin;  refY = &iybin;  refZ = &outbin; }
   if ( projX == GetYaxis() && projY == GetXaxis() ) { refX = &iybin;  refY = &ixbin;  refZ = &outbin; }
   if ( projX == GetXaxis() && projY == GetZaxis() ) { refX = &ixbin;  refY = &outbin; refZ = &iybin;  }
   if ( projX == GetZaxis() && projY == GetXaxis() ) { refX = &iybin;  refY = &outbin; refZ = &ixbin;  }
   if ( projX == GetYaxis() && projY == GetZaxis() ) { refX = &outbin; refY = &ixbin;  refZ = &iybin;  }
   if ( projX == GetZaxis() && projY == GetYaxis() ) { refX = &outbin; refY = &iybin;  refZ = &ixbin;  }
   R__ASSERT (refX != 0 && refY != 0 && refZ != 0);

   Int_t outmin = outAxis->GetFirst();
   Int_t outmax = outAxis->GetLast();
   // GetFirst(), GetLast() can return (0,0) when the range bit is set artifically (see TAxis::SetRange)
   if (outmin == 0 && outmax == 0) { outmin = 1; outmax = outAxis->GetNbins(); }
   // correct for underflow/overflows
   if (useUF && !outAxis->TestBit(TAxis::kAxisRange) )  outmin -= 1;
   if (useOF && !outAxis->TestBit(TAxis::kAxisRange) )  outmax += 1;

   TArrayD & binSumw2 = *(p2->GetBinSumw2());
   if (useWeights && binSumw2.fN <= 0) useWeights = false;
   if (!useWeights) p2->SetBit(TH1::kIsNotW);

   // Call specific method for the projection
   for (ixbin=0;ixbin<=1+projX->GetNbins();ixbin++) {
      if ( (ixbin < ixmin || ixbin > ixmax) && projX->TestBit(TAxis::kAxisRange)) continue;
      for ( iybin=0;iybin<=1+projY->GetNbins();iybin++) {
         if ( (iybin < iymin || iybin > iymax) && projX->TestBit(TAxis::kAxisRange)) continue;

         // profile output bin
         Int_t poutBin = p2->FindBin(projY->GetBinCenter(iybin), projX->GetBinCenter(ixbin));
         if (poutBin <0) continue;
         // loop on the bins to be integrated (outbin should be called inbin)
         for (outbin = outmin; outbin <= outmax; outbin++) {

            Int_t bin = GetBin(*refX,*refY,*refZ);

            //DoFillProfileProjection(p2, *projY, *projX, *outAxis, iybin, ixbin, outbin, bin, useWeights);

            Double_t cont = RetrieveBinContent(bin);
            if (!cont) continue;

            Double_t tmp = 0;
            // the following fill update wrongly the fBinSumw2- need to save it before
            if ( useWeights ) tmp = binSumw2.fArray[poutBin];
            p2->Fill( projY->GetBinCenter(iybin) , projX->GetBinCenter(ixbin), outAxis->GetBinCenter(outbin), cont);
            if (useWeights ) binSumw2.fArray[poutBin] = tmp + fSumw2.fArray[bin];

         }
      }
   }

   // recompute statistics for the projected profiles
   // forget about preserving old statistics
   bool resetStats = true;
   Double_t stats[kNstat];
   // reset statistics
   if (resetStats)
      for (Int_t i=0;i<kNstat;i++) stats[i] = 0;

   p2->PutStats(stats);
   Double_t entries = fEntries;
   // recalculate the statistics
   if (resetStats) {
      entries =  p2->GetEffectiveEntries();
      if (!useWeights) entries = TMath::Floor( entries + 0.5); // to avoid numerical rounding
      p2->SetEntries( entries );
   }

   p2->SetEntries(entries);

   return p2;
}


//______________________________________________________________________________
TProfile2D *TH3::Project3DProfile(Option_t *option) const
{
   // Project a 3-d histogram into a 2-d profile histograms depending
   // on the option parameter
   // option may contain a combination of the characters x,y,z
   // option = "xy" return the x versus y projection into a TProfile2D histogram
   // option = "yx" return the y versus x projection into a TProfile2D histogram
   // option = "xz" return the x versus z projection into a TProfile2D histogram
   // option = "zx" return the z versus x projection into a TProfile2D histogram
   // option = "yz" return the y versus z projection into a TProfile2D histogram
   // option = "zy" return the z versus y projection into a TProfile2D histogram
   // NB: the notation "a vs b" means "a" vertical and "b" horizontal
   //
   // option = "o" original axis range of the target axes will be
   //   kept, but only bins inside the selected range will be filled.
   //
   // The projection is made for the selected bins only.
   // To select a bin range along an axis, use TAxis::SetRange, eg
   //    h3.GetYaxis()->SetRange(23,56);
   //
   // NOTE 1: The generated histogram is named th3name + "_p" + option
   // eg if the TH3* h histogram is named "myhist", then
   // h->Project3D("xy"); produces a TProfile2D histogram named "myhist_pxy".
   // The following sequence
   //    h->Project3DProfile("xy");
   //    h->Project3DProfile("xy2");
   //  will generate two TProfile2D histograms named "myhist_pxy" and "myhist_pxy2"
   //  So, passing additional characters in the option string one can customize the name.
   //
   //  NOTE 2: If a profile of the same type already exists with compatible axes,
   //  the profile is reset and filled again with the projected contents of the TH3.
   //  In the case of axes incompatibility, an error is reported and a NULL pointer is returned.
   //
   //  NOTE 3: The number of entries in the projected profile is estimated from the number of
   //  effective entries for all the cells included in the projection.
   //
   //  NOTE 4: underflow/overflow are by default excluded from the projection
   //  (Note that this is a different default behavior compared to the projection to an histogram)
   //  To include the underflow and/or overflow use option "UF" and/or "OF"

   TString opt = option; opt.ToLower();
   Int_t pcase = 0;
   TString ptype;
   if (opt.Contains("xy")) { pcase = 4; ptype = "xy"; }
   if (opt.Contains("yx")) { pcase = 5; ptype = "yx"; }
   if (opt.Contains("xz")) { pcase = 6; ptype = "xz"; }
   if (opt.Contains("zx")) { pcase = 7; ptype = "zx"; }
   if (opt.Contains("yz")) { pcase = 8; ptype = "yz"; }
   if (opt.Contains("zy")) { pcase = 9; ptype = "zy"; }

   if (pcase == 0) {
      Error("Project3D","No projection axis specified - return a NULL pointer");
      return 0;
   }
   // do not remove ptype from opt to use later in the projected histo name

   Bool_t useUF = kFALSE;
   if (opt.Contains("uf") ) {
      useUF = kTRUE;
      opt.Remove(opt.Index("uf"),2);
   }
   Bool_t useOF = kFALSE;
   if (opt.Contains("of") ) {
      useOF = kTRUE;
      opt.Remove(opt.Index("of"),2);
   }

   Bool_t originalRange = kFALSE;
   if (opt.Contains('o') ) {
      originalRange = kTRUE;
      opt.Remove(opt.First("o"),1);
   }

   // Create the projected profile
   TProfile2D *p2 = 0;
   TString name = GetName();
   TString title = GetTitle();
   name  += "_p";   name  += opt;  // opt may include a user defined name
   title += " profile ";   title += ptype; title += " projection";

   // Call the method with the specific projected axes.
   switch (pcase) {
      case 4:
         // "xy"
         p2 = DoProjectProfile2D(name, title, GetXaxis(), GetYaxis(), originalRange, useUF, useOF);
         break;

      case 5:
         // "yx"
         p2 = DoProjectProfile2D(name, title, GetYaxis(), GetXaxis(), originalRange, useUF, useOF);
         break;

      case 6:
         // "xz"
         p2 = DoProjectProfile2D(name, title, GetXaxis(), GetZaxis(), originalRange, useUF, useOF);
         break;

      case 7:
         // "zx"
         p2 = DoProjectProfile2D(name, title, GetZaxis(), GetXaxis(), originalRange, useUF, useOF);
         break;

      case 8:
         // "yz"
         p2 = DoProjectProfile2D(name, title, GetYaxis(), GetZaxis(), originalRange, useUF, useOF);
         break;

      case 9:
         // "zy"
         p2 = DoProjectProfile2D(name, title, GetZaxis(), GetYaxis(), originalRange, useUF, useOF);
         break;

   }

   return p2;
}


//______________________________________________________________________________
void TH3::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];
   fTsumwz  = stats[7];
   fTsumwz2 = stats[8];
   fTsumwxz = stats[9];
   fTsumwyz = stats[10];
}


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

  return Rebin3D(ngroup, 1, 1, newname);
}


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

  return Rebin3D(1, ngroup, 1, newname);
}


//______________________________________________________________________________
TH3 *TH3::RebinZ(Int_t ngroup, const char *newname)
{
  // Rebin only the Z axis
  // see Rebin3D

  return Rebin3D(1, 1, ngroup, newname);

}


//______________________________________________________________________________
TH3 *TH3::Rebin3D(Int_t nxgroup, Int_t nygroup, Int_t nzgroup, const char *newname)
{
   // Rebin this histogram grouping nxgroup/nygroup/nzgroup bins along the xaxis/yaxis/zaxis 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 TH3 histogram with 40 x 40 x 40 bins
   //     hpxpypz->Rebin3D();  // merges two bins along the xaxis and yaxis in one in hpxpypz
   //                          // Carefull: previous contents of hpxpy are lost
   //     hpxpypz->RebinX(5);  //merges five bins along the xaxis in one in hpxpypz
   //     TH3 *hnew = hpxpypz->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 i,j,k,xbin,ybin,zbin;
   Int_t nxbins  = fXaxis.GetNbins();
   Int_t nybins  = fYaxis.GetNbins();
   Int_t nzbins  = fZaxis.GetNbins();
   Double_t xmin  = fXaxis.GetXmin();
   Double_t xmax  = fXaxis.GetXmax();
   Double_t ymin  = fYaxis.GetXmin();
   Double_t ymax  = fYaxis.GetXmax();
   Double_t zmin  = fZaxis.GetXmin();
   Double_t zmax  = fZaxis.GetXmax();
   if ((nxgroup <= 0) || (nxgroup > nxbins)) {
      Error("Rebin", "Illegal value of nxgroup=%d",nxgroup);
      return 0;
   }
   if ((nygroup <= 0) || (nygroup > nybins)) {
      Error("Rebin", "Illegal value of nygroup=%d",nygroup);
      return 0;
   }
   if ((nzgroup <= 0) || (nzgroup > nzbins)) {
      Error("Rebin", "Illegal value of nzgroup=%d",nzgroup);
      return 0;
   }

   Int_t newxbins = nxbins/nxgroup;
   Int_t newybins = nybins/nygroup;
   Int_t newzbins = nzbins/nzgroup;

   // Save old bin contents into a new array
   Double_t entries = fEntries;
   Double_t *oldBins = new Double_t[fNcells];
   for (Int_t ibin = 0; ibin < fNcells; ibin++) {
      oldBins[ibin] = RetrieveBinContent(ibin);
   }
   Double_t *oldSumw2 = 0;
   if (fSumw2.fN != 0) {
      oldSumw2 = new Double_t[fNcells];
      for (Int_t ibin = 0; ibin < fNcells; ibin++) {
         oldSumw2[ibin] = fSumw2.fArray[ibin];
      }
   }

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

   // save original statistics
   Double_t stat[kNstat];
   GetStats(stat);
   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
   }
   if (newzbins*nzgroup != nzbins) {
      zmax = fZaxis.GetBinUpEdge(newzbins*nzgroup);
      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();
   // save the TAttAxis members (reset by SetBins) for z axis
   Int_t    nZdivisions  = fZaxis.GetNdivisions();
   Color_t  zAxisColor   = fZaxis.GetAxisColor();
   Color_t  zLabelColor  = fZaxis.GetLabelColor();
   Style_t  zLabelFont   = fZaxis.GetLabelFont();
   Float_t  zLabelOffset = fZaxis.GetLabelOffset();
   Float_t  zLabelSize   = fZaxis.GetLabelSize();
   Float_t  zTickLength  = fZaxis.GetTickLength();
   Float_t  zTitleOffset = fZaxis.GetTitleOffset();
   Float_t  zTitleSize   = fZaxis.GetTitleSize();
   Color_t  zTitleColor  = fZaxis.GetTitleColor();
   Style_t  zTitleFont   = fZaxis.GetTitleFont();

   // copy merged bin contents (ignore under/overflows)
   if (nxgroup != 1 || nygroup != 1 || nzgroup != 1) {
      if (fXaxis.GetXbins()->GetSize() > 0 || fYaxis.GetXbins()->GetSize() > 0 || fZaxis.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 (i = 0; i <= newxbins; ++i) xbins[i] = fXaxis.GetBinLowEdge(1+i*nxgroup);
         Double_t *ybins = new Double_t[newybins+1];
         for (i = 0; i <= newybins; ++i) ybins[i] = fYaxis.GetBinLowEdge(1+i*nygroup);
         Double_t *zbins = new Double_t[newzbins+1];
         for (i = 0; i <= newzbins; ++i) zbins[i] = fZaxis.GetBinLowEdge(1+i*nzgroup);
         hnew->SetBins(newxbins,xbins, newybins, ybins, newzbins, zbins);//changes also errors array (if any)
         delete [] xbins;
         delete [] ybins;
         delete [] zbins;
      } else {
         hnew->SetBins(newxbins, xmin, xmax, newybins, ymin, ymax, newzbins, zmin, zmax);//changes also errors array
      }

      Double_t binContent, binSumw2;
      Int_t oldxbin = 1;
      Int_t oldybin = 1;
      Int_t oldzbin = 1;
      Int_t bin;
      for (xbin = 1; xbin <= newxbins; xbin++) {
         oldybin=1;
         oldzbin=1;
         for (ybin = 1; ybin <= newybins; ybin++) {
            oldzbin=1;
            for (zbin = 1; zbin <= newzbins; zbin++) {
               binContent = 0;
               binSumw2   = 0;
               for (i = 0; i < nxgroup; i++) {
                  if (oldxbin+i > nxbins) break;
                  for (j =0; j < nygroup; j++) {
                     if (oldybin+j > nybins) break;
                     for (k =0; k < nzgroup; k++) {
                        if (oldzbin+k > nzbins) break;
                        //get global bin (same conventions as in TH1::GetBin(xbin,ybin)
                        bin = oldxbin + i + (oldybin + j)*(nxbins + 2) + (oldzbin + k)*(nxbins + 2)*(nybins + 2);
                        binContent += oldBins[bin];
                        if (oldSumw2) binSumw2 += oldSumw2[bin];
                     }
                  }
               }
               Int_t ibin = hnew->GetBin(xbin,ybin,zbin);  // new bin number
               hnew->SetBinContent(ibin, binContent);
               if (oldSumw2) hnew->fSumw2.fArray[ibin] = binSumw2;
               oldzbin += nzgroup;
            }
            oldybin += nygroup;
         }
         oldxbin += nxgroup;
      }

      // compute new underflow/overflows for the 8 vertices
      for (Int_t xover = 0; xover <= 1; xover++) {
         for (Int_t yover = 0; yover <= 1; yover++) {
            for (Int_t zover = 0; zover <= 1; zover++) {
               binContent = 0;
               binSumw2 = 0;
               // make loop in case of only underflow/overflow
               for (xbin = xover*oldxbin; xbin <= xover*(nxbins+1); xbin++) {
                  for (ybin = yover*oldybin; ybin <= yover*(nybins+1); ybin++) {
                     for (zbin = zover*oldzbin; zbin <= zover*(nzbins+1); zbin++) {
                        bin = GetBin(xbin,ybin,zbin);
                        binContent += oldBins[bin];
                        if (oldSumw2) binSumw2 += oldSumw2[bin];
                     }
                  }
               }
               Int_t binNew = hnew->GetBin( xover *(newxbins+1),
                                           yover*(newybins+1), zover*(newzbins+1) );
               hnew->SetBinContent(binNew,binContent);
               if (oldSumw2) hnew->fSumw2.fArray[binNew] = binSumw2;
            }
         }
      }

      Double_t binContent0, binContent2, binContent3, binContent4;
      Double_t binError0, binError2, binError3, binError4;
      Int_t oldxbin2, oldybin2, oldzbin2;
      Int_t ufbin, ofbin, ofbin2, ofbin3, ofbin4;

      //  recompute under/overflow contents in y for the new  x and z bins
      oldxbin2 = 1;
      oldybin2 = 1;
      oldzbin2 = 1;
      for (xbin = 1; xbin<=newxbins; xbin++) {
         oldzbin2 = 1;
         for (zbin = 1; zbin<=newzbins; zbin++) {
            binContent0 = binContent2 = 0;
            binError0 = binError2 = 0;
            for (i=0; i<nxgroup; i++) {
               if (oldxbin2+i > nxbins) break;
               for (k=0; k<nzgroup; k++) {
                  if (oldzbin2+k > nzbins) break;
                  //old underflow bin (in y)
                  ufbin = oldxbin2 + i + (nxbins+2)*(nybins+2)*(oldzbin2+k);
                  binContent0 += oldBins[ufbin];
                  if (oldSumw2) binError0 += oldSumw2[ufbin];
                  for (ybin = oldybin; ybin <= nybins + 1; ybin++) {
                     //old overflow bin (in y)
                     ofbin = ufbin + ybin*(nxbins+2);
                     binContent2 += oldBins[ofbin];
                     if (oldSumw2) binError2 += oldSumw2[ofbin];
                  }
               }
            }
            hnew->SetBinContent(xbin,0,zbin,binContent0);
            hnew->SetBinContent(xbin,newybins+1,zbin,binContent2);
            if (oldSumw2) {
               hnew->SetBinError(xbin,0,zbin,TMath::Sqrt(binError0));
               hnew->SetBinError(xbin,newybins+1,zbin,TMath::Sqrt(binError2) );
            }
            oldzbin2 += nzgroup;
         }
         oldxbin2 += nxgroup;
      }

      //  recompute under/overflow contents in x for the new  y and z bins
      oldxbin2 = 1;
      oldybin2 = 1;
      oldzbin2 = 1;
      for (ybin = 1; ybin<=newybins; ybin++) {
         oldzbin2 = 1;
         for (zbin = 1; zbin<=newzbins; zbin++) {
            binContent0 = binContent2 = 0;
            binError0 = binError2 = 0;
            for (j=0; j<nygroup; j++) {
               if (oldybin2+j > nybins) break;
               for (k=0; k<nzgroup; k++) {
                  if (oldzbin2+k > nzbins) break;
                  //old underflow bin (in y)
                  ufbin = (oldybin2 + j)*(nxbins+2) + (nxbins+2)*(nybins+2)*(oldzbin2+k);
                  binContent0 += oldBins[ufbin];
                  if (oldSumw2) binError0 += oldSumw2[ufbin];
                  for (xbin = oldxbin; xbin <= nxbins + 1; xbin++) {
                     //old overflow bin (in x)
                     ofbin = ufbin + xbin;
                     binContent2 += oldBins[ofbin];
                     if (oldSumw2) binError2 += oldSumw2[ofbin];
                  }
               }
            }
            hnew->SetBinContent(0,ybin,zbin,binContent0);
            hnew->SetBinContent(newxbins+1,ybin,zbin,binContent2);
            if (oldSumw2) {
               hnew->SetBinError(0,ybin,zbin,TMath::Sqrt(binError0));
               hnew->SetBinError(newxbins+1,ybin,zbin,TMath::Sqrt(binError2) );
            }
            oldzbin2 += nzgroup;
         }
         oldybin2 += nygroup;
      }

      //  recompute under/overflow contents in z for the new  x and y bins
      oldxbin2 = 1;
      oldybin2 = 1;
      oldzbin2 = 1;
      for (xbin = 1; xbin<=newxbins; xbin++) {
         oldybin2 = 1;
         for (ybin = 1; ybin<=newybins; ybin++) {
            binContent0 = binContent2 = 0;
            binError0 = binError2 = 0;
            for (i=0; i<nxgroup; i++) {
               if (oldxbin2+i > nxbins) break;
               for (j=0; j<nygroup; j++) {
                  if (oldybin2+j > nybins) break;
                  //old underflow bin (in z)
                  ufbin = oldxbin2 + i + (nxbins+2)*(oldybin2+j);
                  binContent0 += oldBins[ufbin];
                  if (oldSumw2) binError0 += oldSumw2[ufbin];
                  for (zbin = oldzbin; zbin <= nzbins + 1; zbin++) {
                     //old overflow bin (in z)
                     ofbin = ufbin + (nxbins+2)*(nybins+2)*zbin;
                     binContent2 += oldBins[ofbin];
                     if (oldSumw2) binError2 += oldSumw2[ofbin];
                  }
               }
            }
            hnew->SetBinContent(xbin,ybin,0,binContent0);
            hnew->SetBinContent(xbin,ybin,newzbins+1,binContent2);
            if (oldSumw2) {
               hnew->SetBinError(xbin,ybin,0,TMath::Sqrt(binError0));
               hnew->SetBinError(xbin,ybin,newzbins+1,TMath::Sqrt(binError2) );
            }
            oldybin2 += nygroup;
         }
         oldxbin2 += nxgroup;
      }

      //  recompute under/overflow contents in y, z for the new  x
      oldxbin2 = 1;
      oldybin2 = 1;
      oldzbin2 = 1;
      for (xbin = 1; xbin<=newxbins; xbin++) {
         binContent0 = 0;
         binContent2 = 0;
         binContent3 = 0;
         binContent4 = 0;
         binError0 = 0;
         binError2 = 0;
         binError3 = 0;
         binError4 = 0;
         for (i=0; i<nxgroup; i++) {
            if (oldxbin2+i > nxbins) break;
            ufbin = oldxbin2 + i; //
            binContent0 += oldBins[ufbin];
            if (oldSumw2) binError0 += oldSumw2[ufbin];
            for (ybin = oldybin; ybin <= nybins + 1; ybin++) {
               ofbin3 =  ufbin+ybin*(nxbins+2);
               binContent3 += oldBins[ ofbin3 ];
               if (oldSumw2)  binError3 += oldSumw2[ofbin3];
               for (zbin = oldzbin; zbin <= nzbins + 1; zbin++) {
                  //old overflow bin (in z)
                  ofbin4 =   oldxbin2 + i + ybin*(nxbins+2) + (nxbins+2)*(nybins+2)*zbin;
                  binContent4 += oldBins[ofbin4];
                  if (oldSumw2) binError4 += oldSumw2[ofbin4];
               }
            }
            for (zbin = oldzbin; zbin <= nzbins + 1; zbin++) {
               ofbin2 =  ufbin+zbin*(nxbins+2)*(nybins+2);
               binContent2 += oldBins[ ofbin2 ];
               if (oldSumw2)  binError2 += oldSumw2[ofbin2];
            }
         }
         hnew->SetBinContent(xbin,0,0,binContent0);
         hnew->SetBinContent(xbin,0,newzbins+1,binContent2);
         hnew->SetBinContent(xbin,newybins+1,0,binContent3);
         hnew->SetBinContent(xbin,newybins+1,newzbins+1,binContent4);
         if (oldSumw2) {
            hnew->SetBinError(xbin,0,0,TMath::Sqrt(binError0));
            hnew->SetBinError(xbin,0,newzbins+1,TMath::Sqrt(binError2) );
            hnew->SetBinError(xbin,newybins+1,0,TMath::Sqrt(binError3) );
            hnew->SetBinError(xbin,newybins+1,newzbins+1,TMath::Sqrt(binError4) );
         }
         oldxbin2 += nxgroup;
      }

      //  recompute under/overflow contents in x, y for the new z
      oldxbin2 = 1;
      oldybin2 = 1;
      oldzbin2 = 1;
      for (zbin = 1; zbin<=newzbins; zbin++) {
         binContent0 = 0;
         binContent2 = 0;
         binContent3 = 0;
         binContent4 = 0;
         binError0 = 0;
         binError2 = 0;
         binError3 = 0;
         binError4 = 0;
         for (i=0; i<nzgroup; i++) {
            if (oldzbin2+i > nzbins) break;
            ufbin = (oldzbin2 + i)*(nxbins+2)*(nybins+2); //
            binContent0 += oldBins[ufbin];
            if (oldSumw2) binError0 += oldSumw2[ufbin];
            for (ybin = oldybin; ybin <= nybins + 1; ybin++) {
               ofbin3 =  ufbin+ybin*(nxbins+2);
               binContent3 += oldBins[ ofbin3 ];
               if (oldSumw2)  binError3 += oldSumw2[ofbin3];
               for (xbin = oldxbin; xbin <= nxbins + 1; xbin++) {
                  //old overflow bin (in z)
                  ofbin4 = ufbin + xbin + ybin*(nxbins+2);
                  binContent4 += oldBins[ofbin4];
                  if (oldSumw2) binError4 += oldSumw2[ofbin4];
               }
            }
            for (xbin = oldxbin; xbin <= nxbins + 1; xbin++) {
               ofbin2 =  xbin +(oldzbin2+i)*(nxbins+2)*(nybins+2);
               binContent2 += oldBins[ ofbin2 ];
               if (oldSumw2)  binError2 += oldSumw2[ofbin2];
            }
         }
         hnew->SetBinContent(0,0,zbin,binContent0);
         hnew->SetBinContent(0,newybins+1,zbin,binContent3);
         hnew->SetBinContent(newxbins+1,0,zbin,binContent2);
         hnew->SetBinContent(newxbins+1,newybins+1,zbin,binContent4);
         if (oldSumw2) {
            hnew->SetBinError(0,0,zbin,TMath::Sqrt(binError0));
            hnew->SetBinError(0,newybins+1,zbin,TMath::Sqrt(binError3) );
            hnew->SetBinError(newxbins+1,0,zbin,TMath::Sqrt(binError2) );
            hnew->SetBinError(newxbins+1,newybins+1,zbin,TMath::Sqrt(binError4) );
         }
         oldzbin2 += nzgroup;
      }

      //  recompute under/overflow contents in x, z for the new  y
      oldxbin2 = 1;
      oldybin2 = 1;
      oldzbin2 = 1;
      for (ybin = 1; ybin<=newybins; ybin++) {
         binContent0 = 0;
         binContent2 = 0;
         binContent3 = 0;
         binContent4 = 0;
         binError0 = 0;
         binError2 = 0;
         binError3 = 0;
         binError4 = 0;
         for (i=0; i<nygroup; i++) {
            if (oldybin2+i > nybins) break;
            ufbin = (oldybin2 + i)*(nxbins+2); //
            binContent0 += oldBins[ufbin];
            if (oldSumw2) binError0 += oldSumw2[ufbin];
            for (xbin = oldxbin; xbin <= nxbins + 1; xbin++) {
               ofbin3 =  ufbin+xbin;
               binContent3 += oldBins[ ofbin3 ];
               if (oldSumw2)  binError3 += oldSumw2[ofbin3];
               for (zbin = oldzbin; zbin <= nzbins + 1; zbin++) {
                  //old overflow bin (in z)
                  ofbin4 = xbin + (nxbins+2)*(nybins+2)*zbin+(oldybin2+i)*(nxbins+2);
                  binContent4 += oldBins[ofbin4];
                  if (oldSumw2) binError4 += oldSumw2[ofbin4];
               }
            }
            for (zbin = oldzbin; zbin <= nzbins + 1; zbin++) {
               ofbin2 =  (oldybin2+i)*(nxbins+2)+zbin*(nxbins+2)*(nybins+2);
               binContent2 += oldBins[ ofbin2 ];
               if (oldSumw2)  binError2 += oldSumw2[ofbin2];
            }
         }
         hnew->SetBinContent(0,ybin,0,binContent0);
         hnew->SetBinContent(0,ybin,newzbins+1,binContent2);
         hnew->SetBinContent(newxbins+1,ybin,0,binContent3);
         hnew->SetBinContent(newxbins+1,ybin,newzbins+1,binContent4);
         if (oldSumw2) {
            hnew->SetBinError(0,ybin,0,TMath::Sqrt(binError0));
            hnew->SetBinError(0,ybin,newzbins+1,TMath::Sqrt(binError2) );
            hnew->SetBinError(newxbins+1,ybin,0,TMath::Sqrt(binError3) );
            hnew->SetBinError(newxbins+1,ybin,newzbins+1,TMath::Sqrt(binError4) );
         }
         oldybin2 += nygroup;
      }
   }

   // 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);
   // Restore z axis attributes
   fZaxis.SetNdivisions(nZdivisions);
   fZaxis.SetAxisColor(zAxisColor);
   fZaxis.SetLabelColor(zLabelColor);
   fZaxis.SetLabelFont(zLabelFont);
   fZaxis.SetLabelOffset(zLabelOffset);
   fZaxis.SetLabelSize(zLabelSize);
   fZaxis.SetTickLength(zTickLength);
   fZaxis.SetTitleOffset(zTitleOffset);
   fZaxis.SetTitleSize(zTitleSize);
   fZaxis.SetTitleColor(zTitleColor);
   fZaxis.SetTitleFont(zTitleFont);

   //restore statistics and entries  modified by SetBinContent
   hnew->SetEntries(entries);
   if (!resetStat) hnew->PutStats(stat);

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


//______________________________________________________________________________
void TH3::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;
   fTsumwz  = 0;
   fTsumwz2 = 0;
   fTsumwxz = 0;
   fTsumwyz = 0;
}


//______________________________________________________________________________
void TH3::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 TH3::Streamer(TBuffer &R__b)
{
   // Stream an object of class TH3.

   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(TH3::Class(), this, R__v, R__s, R__c);
         return;
      }
      //====process old versions before automatic schema evolution
      TH1::Streamer(R__b);
      TAtt3D::Streamer(R__b);
      R__b.CheckByteCount(R__s, R__c, TH3::IsA());
      //====end of old versions

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


//______________________________________________________________________________
//                     TH3C methods
//  TH3C a 3-D histogram with one byte per cell (char)
//______________________________________________________________________________

ClassImp(TH3C)


//______________________________________________________________________________
TH3C::TH3C(): TH3(), TArrayC()
{
   // Constructor.

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


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


//______________________________________________________________________________
TH3C::TH3C(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,Double_t ylow,Double_t yup
           ,Int_t nbinsz,Double_t zlow,Double_t zup)
           :TH3(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup,nbinsz,zlow,zup)
{
   // Normal constructor for fix bin size 3-D histograms.

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

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


//______________________________________________________________________________
TH3C::TH3C(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
           ,Int_t nbinsy,const Float_t *ybins
           ,Int_t nbinsz,const Float_t *zbins)
           :TH3(name,title,nbinsx,xbins,nbinsy,ybins,nbinsz,zbins)
{
   // Normal constructor for variable bin size 3-D histograms.

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


//______________________________________________________________________________
TH3C::TH3C(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,const Double_t *ybins
           ,Int_t nbinsz,const Double_t *zbins)
           :TH3(name,title,nbinsx,xbins,nbinsy,ybins,nbinsz,zbins)
{
   // Normal constructor for variable bin size 3-D histograms.

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


//______________________________________________________________________________
TH3C::TH3C(const TH3C &h3c) : TH3(), TArrayC()
{
   // Copy constructor.

   ((TH3C&)h3c).Copy(*this);
}


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

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


//______________________________________________________________________________
void TH3C::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 TH3C::Copy(TObject &newth3) const
{
   // Copy this 3-D histogram structure to newth3.

   TH3::Copy((TH3C&)newth3);
}


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

   TH3::Reset(option);
   TArrayC::Reset();
   // should also reset statistics once statistics are implemented for TH3
}


//______________________________________________________________________________
void TH3C::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)*(fZaxis.GetNbins()+2);
   fNcells = n;
   TArrayC::Set(n);
}


//______________________________________________________________________________
void TH3::SetShowProjection(const char *option,Int_t nbins)
{
   // When the mouse is moved in a pad containing a 3-d view of this histogram
   // a second canvas shows a projection type given as option.
   // To stop the generation of the projections, delete the canvas
   // containing the projection.
   // option may contain a combination of the characters x,y,z,e
   // option = "x" return the x projection into a TH1D histogram
   // option = "y" return the y projection into a TH1D histogram
   // option = "z" return the z projection into a TH1D histogram
   // option = "xy" return the x versus y projection into a TH2D histogram
   // option = "yx" return the y versus x projection into a TH2D histogram
   // option = "xz" return the x versus z projection into a TH2D histogram
   // option = "zx" return the z versus x projection into a TH2D histogram
   // option = "yz" return the y versus z projection into a TH2D histogram
   // option = "zy" return the z versus y projection into a TH2D histogram
   // option can also include the drawing option for the projection, eg to draw
   // the xy projection using the draw option "box" do
   //   myhist.SetShowProjection("xy box");
   // This function is typically called from the context menu.
   // NB: the notation "a vs b" means "a" vertical and "b" horizontal

   GetPainter();

   if (fPainter) fPainter->SetShowProjection(option,nbins);
}


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

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      if (R__b.GetParent() && R__b.GetVersionOwner() < 22300) return;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      if (R__v > 2) {
         R__b.ReadClassBuffer(TH3C::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__s, &R__c);
         TAtt3D::Streamer(R__b);
      } else {
         TH3::Streamer(R__b);
         TArrayC::Streamer(R__b);
         R__b.CheckByteCount(R__s, R__c, TH3C::IsA());
      }
      //====end of old versions

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


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

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


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

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


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

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


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

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


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

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


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

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


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

ClassImp(TH3S)


//______________________________________________________________________________
TH3S::TH3S(): TH3(), TArrayS()
{
   // Constructor.

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


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


//______________________________________________________________________________
TH3S::TH3S(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,Double_t ylow,Double_t yup
           ,Int_t nbinsz,Double_t zlow,Double_t zup)
           :TH3(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup,nbinsz,zlow,zup)
{
   // Normal constructor for fix bin size 3-D histograms.

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

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


//______________________________________________________________________________
TH3S::TH3S(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
           ,Int_t nbinsy,const Float_t *ybins
           ,Int_t nbinsz,const Float_t *zbins)
           :TH3(name,title,nbinsx,xbins,nbinsy,ybins,nbinsz,zbins)
{
   // Normal constructor for variable bin size 3-D histograms.

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


//______________________________________________________________________________
TH3S::TH3S(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,const Double_t *ybins
           ,Int_t nbinsz,const Double_t *zbins)
           :TH3(name,title,nbinsx,xbins,nbinsy,ybins,nbinsz,zbins)
{
   // Normal constructor for variable bin size 3-D histograms.

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


//______________________________________________________________________________
TH3S::TH3S(const TH3S &h3s) : TH3(), TArrayS()
{
   // Copy Constructor.

   ((TH3S&)h3s).Copy(*this);
}


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

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


//______________________________________________________________________________
void TH3S::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 TH3S::Copy(TObject &newth3) const
{
   // Copy this 3-D histogram structure to newth3.

   TH3::Copy((TH3S&)newth3);
}


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

   TH3::Reset(option);
   TArrayS::Reset();
   // should also reset statistics once statistics are implemented for TH3
}


//______________________________________________________________________________
void TH3S::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)*(fZaxis.GetNbins()+2);
   fNcells = n;
   TArrayS::Set(n);
}


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

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      if (R__b.GetParent() && R__b.GetVersionOwner() < 22300) return;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      if (R__v > 2) {
         R__b.ReadClassBuffer(TH3S::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__s, &R__c);
         TAtt3D::Streamer(R__b);
      } else {
         TH3::Streamer(R__b);
         TArrayS::Streamer(R__b);
         R__b.CheckByteCount(R__s, R__c, TH3S::IsA());
      }
      //====end of old versions

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


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

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


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

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


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

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


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

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


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

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


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

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


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

ClassImp(TH3I)


//______________________________________________________________________________
TH3I::TH3I(): TH3(), TArrayI()
{
   // Constructor.

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


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


//______________________________________________________________________________
TH3I::TH3I(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,Double_t ylow,Double_t yup
           ,Int_t nbinsz,Double_t zlow,Double_t zup)
           :TH3(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup,nbinsz,zlow,zup)
{
   // Normal constructor for fix bin size 3-D histograms.

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

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


//______________________________________________________________________________
TH3I::TH3I(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
           ,Int_t nbinsy,const Float_t *ybins
           ,Int_t nbinsz,const Float_t *zbins)
           :TH3(name,title,nbinsx,xbins,nbinsy,ybins,nbinsz,zbins)
{
   // Normal constructor for variable bin size 3-D histograms.

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


//______________________________________________________________________________
TH3I::TH3I(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,const Double_t *ybins
           ,Int_t nbinsz,const Double_t *zbins)
           :TH3(name,title,nbinsx,xbins,nbinsy,ybins,nbinsz,zbins)
{
   // Normal constructor for variable bin size 3-D histograms.

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


//______________________________________________________________________________
TH3I::TH3I(const TH3I &h3i) : TH3(), TArrayI()
{
   // Copy constructor.

   ((TH3I&)h3i).Copy(*this);
}


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

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


//______________________________________________________________________________
void TH3I::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 TH3I::Copy(TObject &newth3) const
{
   // Copy this 3-D histogram structure to newth3.

   TH3::Copy((TH3I&)newth3);
}


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

   TH3::Reset(option);
   TArrayI::Reset();
   // should also reset statistics once statistics are implemented for TH3
}


//______________________________________________________________________________
void TH3I::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)*(fZaxis.GetNbins()+2);
   fNcells = n;
   TArrayI::Set(n);
}


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

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


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

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


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

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


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

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


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

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


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

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


//______________________________________________________________________________
//                     TH3F methods
//  TH3F a 3-D histogram with four bytes per cell (float)
//______________________________________________________________________________

ClassImp(TH3F)


//______________________________________________________________________________
TH3F::TH3F(): TH3(), TArrayF()
{
   // Constructor.

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


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


//______________________________________________________________________________
TH3F::TH3F(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,Double_t ylow,Double_t yup
           ,Int_t nbinsz,Double_t zlow,Double_t zup)
           :TH3(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup,nbinsz,zlow,zup)
{
   // Normal constructor for fix bin size 3-D histograms.

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

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


//______________________________________________________________________________
TH3F::TH3F(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
           ,Int_t nbinsy,const Float_t *ybins
           ,Int_t nbinsz,const Float_t *zbins)
           :TH3(name,title,nbinsx,xbins,nbinsy,ybins,nbinsz,zbins)
{
   // Normal constructor for variable bin size 3-D histograms.

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


//______________________________________________________________________________
TH3F::TH3F(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,const Double_t *ybins
           ,Int_t nbinsz,const Double_t *zbins)
           :TH3(name,title,nbinsx,xbins,nbinsy,ybins,nbinsz,zbins)
{
   // Normal constructor for variable bin size 3-D histograms.

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


//______________________________________________________________________________
TH3F::TH3F(const TH3F &h3f) : TH3(), TArrayF()
{
   // Copy constructor.

   ((TH3F&)h3f).Copy(*this);
}


//______________________________________________________________________________
void TH3F::Copy(TObject &newth3) const
{
   // Copy this 3-D histogram structure to newth3.

   TH3::Copy((TH3F&)newth3);
}


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

   TH3::Reset(option);
   TArrayF::Reset();
   // should also reset statistics once statistics are implemented for TH3
}


//______________________________________________________________________________
void TH3F::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)*(fZaxis.GetNbins()+2);
   fNcells = n;
   TArrayF::Set(n);
}


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

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      if (R__b.GetParent() && R__b.GetVersionOwner() < 22300) return;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      if (R__v > 2) {
         R__b.ReadClassBuffer(TH3F::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__s, &R__c);
         TAtt3D::Streamer(R__b);
      } else {
         TH3::Streamer(R__b);
         TArrayF::Streamer(R__b);
         R__b.CheckByteCount(R__s, R__c, TH3F::IsA());
      }
      //====end of old versions

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


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

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


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

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


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

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


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

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


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

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


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

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


//______________________________________________________________________________
//                     TH3D methods
//  TH3D a 3-D histogram with eight bytes per cell (double)
//______________________________________________________________________________

ClassImp(TH3D)


//______________________________________________________________________________
TH3D::TH3D(): TH3(), TArrayD()
{
   // Constructor.

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


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


//______________________________________________________________________________
TH3D::TH3D(const char *name,const char *title,Int_t nbinsx,Double_t xlow,Double_t xup
           ,Int_t nbinsy,Double_t ylow,Double_t yup
           ,Int_t nbinsz,Double_t zlow,Double_t zup)
           :TH3(name,title,nbinsx,xlow,xup,nbinsy,ylow,yup,nbinsz,zlow,zup)
{
   // Normal constructor for fix bin size 3-D histograms.

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

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


//______________________________________________________________________________
TH3D::TH3D(const char *name,const char *title,Int_t nbinsx,const Float_t *xbins
           ,Int_t nbinsy,const Float_t *ybins
           ,Int_t nbinsz,const Float_t *zbins)
           :TH3(name,title,nbinsx,xbins,nbinsy,ybins,nbinsz,zbins)
{
   // Normal constructor for variable bin size 3-D histograms.

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


//______________________________________________________________________________
TH3D::TH3D(const char *name,const char *title,Int_t nbinsx,const Double_t *xbins
           ,Int_t nbinsy,const Double_t *ybins
           ,Int_t nbinsz,const Double_t *zbins)
           :TH3(name,title,nbinsx,xbins,nbinsy,ybins,nbinsz,zbins)
{
   // Normal constructor for variable bin size 3-D histograms.

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


//______________________________________________________________________________
TH3D::TH3D(const TH3D &h3d) : TH3(), TArrayD()
{
   // Copy constructor.

   ((TH3D&)h3d).Copy(*this);
}


//______________________________________________________________________________
void TH3D::Copy(TObject &newth3) const
{
   // Copy this 3-D histogram structure to newth3.

   TH3::Copy((TH3D&)newth3);
}


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

   TH3::Reset(option);
   TArrayD::Reset();
   // should also reset statistics once statistics are implemented for TH3
}


//______________________________________________________________________________
void TH3D::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)*(fZaxis.GetNbins()+2);
   fNcells = n;
   TArrayD::Set(n);
}


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

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      if (R__b.GetParent() && R__b.GetVersionOwner() < 22300) return;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      if (R__v > 2) {
         R__b.ReadClassBuffer(TH3D::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__s, &R__c);
         TAtt3D::Streamer(R__b);
      } else {
         TH3::Streamer(R__b);
         TArrayD::Streamer(R__b);
         R__b.CheckByteCount(R__s, R__c, TH3D::IsA());
      }
      //====end of old versions

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


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

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


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

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


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

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


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

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


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

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


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

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