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

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

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>

#include "Riostream.h"
#include "TROOT.h"
#include "TClass.h"
#include "TMath.h"
#include "THashList.h"
#include "TH1.h"
#include "TH2.h"
#include "TF2.h"
#include "TF3.h"
#include "TPluginManager.h"
#include "TVirtualPad.h"
#include "TRandom.h"
#include "TVirtualFitter.h"
#include "THLimitsFinder.h"
#include "TProfile.h"
#include "TStyle.h"
#include "TVectorF.h"
#include "TVectorD.h"
#include "TBrowser.h"
#include "TObjString.h"
#include "TError.h"
#include "TVirtualHistPainter.h"
#include "TVirtualFFT.h"
#include "TSystem.h"

#include "HFitInterface.h"
#include "Fit/DataRange.h"
#include "Fit/BinData.h"
#include "Math/GoFTest.h"
#include "Math/MinimizerOptions.h"
#include "Math/QuantFuncMathCore.h"


//______________________________________________________________________________
/* Begin_Html
<center><h2>The Histogram classes</h2></center>
ROOT supports the following histogram types:
<ul>
  <li>1-D histograms:
   <ul>
         <li>TH1C : histograms with one byte per channel.   Maximum bin content = 127
         <li>TH1S : histograms with one short per channel.  Maximum bin content = 32767
         <li>TH1I : histograms with one int per channel.    Maximum bin content = 2147483647
         <li>TH1F : histograms with one float per channel.  Maximum precision 7 digits
         <li>TH1D : histograms with one double per channel. Maximum precision 14 digits
   </ul>

  <li>2-D histograms:
   <ul>
         <li>TH2C : histograms with one byte per channel.   Maximum bin content = 127
         <li>TH2S : histograms with one short per channel.  Maximum bin content = 32767
         <li>TH2I : histograms with one int per channel.    Maximum bin content = 2147483647
         <li>TH2F : histograms with one float per channel.  Maximum precision 7 digits
         <li>TH2D : histograms with one double per channel. Maximum precision 14 digits
   </ul>

  <li>3-D histograms:
   <ul>
         <li>TH3C : histograms with one byte per channel.   Maximum bin content = 127
         <li>TH3S : histograms with one short per channel.  Maximum bin content = 32767
         <li>TH3I : histograms with one int per channel.    Maximum bin content = 2147483647
         <li>TH3F : histograms with one float per channel.  Maximum precision 7 digits
         <li>TH3D : histograms with one double per channel. Maximum precision 14 digits
   </ul>
  <li>Profile histograms: See classes  TProfile, TProfile2D and TProfile3D.
      Profile histograms are used to display the mean value of Y and its RMS
      for each bin in X. Profile histograms are in many cases an elegant
      replacement of two-dimensional histograms : the inter-relation of two
      measured quantities X and Y can always be visualized by a two-dimensional
      histogram or scatter-plot; If Y is an unknown (but single-valued)
      approximate function of X, this function is displayed by a profile
      histogram with much better precision than by a scatter-plot.
</ul>

All histogram classes are derived from the base class TH1
<pre>
                                TH1
                                 ^
                                 |
                                 |
                                 |
         -----------------------------------------------------------
                |                |       |      |      |     |     |
                |                |      TH1C   TH1S   TH1I  TH1F  TH1D
                |                |                                 |
                |                |                                 |
                |               TH2                             TProfile
                |                |
                |                |
                |                ----------------------------------
                |                        |      |      |     |     |
                |                       TH2C   TH2S   TH2I  TH2F  TH2D
                |                                                  |
               TH3                                                 |
                |                                               TProfile2D
                |
                -------------------------------------
                        |      |      |      |      |
                       TH3C   TH3S   TH3I   TH3F   TH3D
                                                    |
                                                    |
                                                 TProfile3D

      The TH*C classes also inherit from the array class TArrayC.
      The TH*S classes also inherit from the array class TArrayS.
      The TH*I classes also inherit from the array class TArrayI.
      The TH*F classes also inherit from the array class TArrayF.
      The TH*D classes also inherit from the array class TArrayD.
</pre>

<h4>Creating histograms</h4>
<p>
     Histograms are created by invoking one of the constructors, e.g.
<pre>
       TH1F *h1 = new TH1F("h1", "h1 title", 100, 0, 4.4);
       TH2F *h2 = new TH2F("h2", "h2 title", 40, 0, 4, 30, -3, 3);
</pre>
<p>  Histograms may also be created by:
  <ul>
      <li> calling the Clone function, see below
      <li> making a projection from a 2-D or 3-D histogram, see below
      <li> reading an histogram from a file
   </ul>
<p>  When an histogram is created, a reference to it is automatically added
     to the list of in-memory objects for the current file or directory.
     This default behaviour can be changed by:
<pre>
       h->SetDirectory(0);          for the current histogram h
       TH1::AddDirectory(kFALSE);   sets a global switch disabling the reference
</pre>
     When the histogram is deleted, the reference to it is removed from
     the list of objects in memory.
     When a file is closed, all histograms in memory associated with this file
     are automatically deleted.

<h4>Fix or variable bin size</h4>

     All histogram types support either fix or variable bin sizes.
     2-D histograms may have fix size bins along X and variable size bins
     along Y or vice-versa. The functions to fill, manipulate, draw or access
     histograms are identical in both cases.
<p>     Each histogram always contains 3 objects TAxis: fXaxis, fYaxis and fZaxis
     To access the axis parameters, do:
<pre>
        TAxis *xaxis = h->GetXaxis(); etc.
        Double_t binCenter = xaxis->GetBinCenter(bin), etc.
</pre>
     See class TAxis for a description of all the access functions.
     The axis range is always stored internally in double precision.

<h4>Convention for numbering bins</h4>

      For all histogram types: nbins, xlow, xup
<pre>
        bin = 0;       underflow bin
        bin = 1;       first bin with low-edge xlow INCLUDED
        bin = nbins;   last bin with upper-edge xup EXCLUDED
        bin = nbins+1; overflow bin
</pre>
<p>      In case of 2-D or 3-D histograms, a "global bin" number is defined.
      For example, assuming a 3-D histogram with (binx, biny, binz), the function
<pre>
        Int_t gbin = h->GetBin(binx, biny, binz);
</pre>
      returns a global/linearized gbin number. This global gbin is useful
      to access the bin content/error information independently of the dimension.
      Note that to access the information other than bin content and errors
      one should use the TAxis object directly with e.g.:
<pre>
         Double_t xcenter = h3->GetZaxis()->GetBinCenter(27);
</pre>
       returns the center along z of bin number 27 (not the global bin)
       in the 3-D histogram h3.

<h4>Alphanumeric Bin Labels</h4>

     By default, an histogram axis is drawn with its numeric bin labels.
     One can specify alphanumeric labels instead with:
<ul>
       <li> call TAxis::SetBinLabel(bin, label);
           This can always be done before or after filling.
           When the histogram is drawn, bin labels will be automatically drawn.
           See example in $ROOTSYS/tutorials/graphs/labels1.C, labels2.C
       <li> call to a Fill function with one of the arguments being a string, e.g.
<pre>
           hist1->Fill(somename, weigth);
           hist2->Fill(x, somename, weight);
           hist2->Fill(somename, y, weight);
           hist2->Fill(somenamex, somenamey, weight);
</pre>
           See example in $ROOTSYS/tutorials/hist/hlabels1.C, hlabels2.C
       <li> via TTree::Draw.
           see for example $ROOTSYS/tutorials/tree/cernstaff.C
<pre>
           tree.Draw("Nation::Division");
</pre>
           where "Nation" and "Division" are two branches of a Tree.
</ul>

<p>     When using the options 2 or 3 above, the labels are automatically
     added to the list (THashList) of labels for a given axis.
     By default, an axis is drawn with the order of bins corresponding
     to the filling sequence. It is possible to reorder the axis

<ul>
          <li>alphabetically
          <li>by increasing or decreasing values
</ul>

<p>     The reordering can be triggered via the TAxis context menu by selecting
     the menu item "LabelsOption" or by calling directly
        TH1::LabelsOption(option, axis) where
<ul>
          <li>axis may be "X", "Y" or "Z"
          <li>option may be:
           <ul>
             <li>"a" sort by alphabetic order
             <li>">" sort by decreasing values
             <li>"<" sort by increasing values
             <li>"h" draw labels horizontal
             <li>"v" draw labels vertical
             <li>"u" draw labels up (end of label right adjusted)
             <li>"d" draw labels down (start of label left adjusted)
           </ul>
</ul>
<p>     When using the option 2 above, new labels are added by doubling the current
     number of bins in case one label does not exist yet.
     When the Filling is terminated, it is possible to trim the number
     of bins to match the number of active labels by calling
<pre>
           TH1::LabelsDeflate(axis) with axis = "X", "Y" or "Z"
</pre>
     This operation is automatic when using TTree::Draw.
     Once bin labels have been created, they become persistent if the histogram
     is written to a file or when generating the C++ code via SavePrimitive.

<h4>Histograms with automatic bins</h4>

     When an histogram is created with an axis lower limit greater or equal
     to its upper limit, the SetBuffer is automatically called with an
     argument fBufferSize equal to fgBufferSize (default value=1000).
     fgBufferSize may be reset via the static function TH1::SetDefaultBufferSize.
     The axis limits will be automatically computed when the buffer will
     be full or when the function BufferEmpty is called.

<h4>Filling histograms</h4>

     An histogram is typically filled with statements like:
<pre>
       h1->Fill(x);
       h1->Fill(x, w); //fill with weight
       h2->Fill(x, y)
       h2->Fill(x, y, w)
       h3->Fill(x, y, z)
       h3->Fill(x, y, z, w)
</pre>
     or via one of the Fill functions accepting names described above.
     The Fill functions compute the bin number corresponding to the given
     x, y or z argument and increment this bin by the given weight.
     The Fill functions return the bin number for 1-D histograms or global
     bin number for 2-D and 3-D histograms.
<p>     If TH1::Sumw2 has been called before filling, the sum of squares of
     weights is also stored.
     One can also increment directly a bin number via TH1::AddBinContent
     or replace the existing content via TH1::SetBinContent.
     To access the bin content of a given bin, do:
<pre>
       Double_t binContent = h->GetBinContent(bin);
</pre>

<p>     By default, the bin number is computed using the current axis ranges.
     If the automatic binning option has been set via
<pre>
       h->SetCanExtend(kAllAxes);
</pre>
     then, the Fill Function will automatically extend the axis range to
     accomodate the new value specified in the Fill argument. The method
     used is to double the bin size until the new value fits in the range,
     merging bins two by two. This automatic binning options is extensively
     used by the TTree::Draw function when histogramming Tree variables
     with an unknown range.
<p>     This automatic binning option is supported for 1-D, 2-D and 3-D histograms.

     During filling, some statistics parameters are incremented to compute
     the mean value and Root Mean Square with the maximum precision.

<p>     In case of histograms of type TH1C, TH1S, TH2C, TH2S, TH3C, TH3S
     a check is made that the bin contents do not exceed the maximum positive
     capacity (127 or 32767). Histograms of all types may have positive
     or/and negative bin contents.

<h4>Rebinning</h4>

     At any time, an histogram can be rebinned via TH1::Rebin. This function
     returns a new histogram with the rebinned contents.
     If bin errors were stored, they are recomputed during the rebinning.

<h4>Associated errors</h4>

     By default, for each bin, the sum of weights is computed at fill time.
     One can also call TH1::Sumw2 to force the storage and computation
     of the sum of the square of weights per bin.
     If Sumw2 has been called, the error per bin is computed as the
     sqrt(sum of squares of weights), otherwise the error is set equal
     to the sqrt(bin content).
     To return the error for a given bin number, do:
<pre>
        Double_t error = h->GetBinError(bin);
</pre>

<h4>Associated functions</h4>

     One or more object (typically a TF1*) can be added to the list
     of functions (fFunctions) associated to each histogram.
     When TH1::Fit is invoked, the fitted function is added to this list.
     Given an histogram h, one can retrieve an associated function
     with:
<pre>
        TF1 *myfunc = h->GetFunction("myfunc");
</pre>

<h4>Operations on histograms</h4>


     Many types of operations are supported on histograms or between histograms
<ul>
     <li> Addition of an histogram to the current histogram.
     <li> Additions of two histograms with coefficients and storage into the current
       histogram.
     <li> Multiplications and Divisions are supported in the same way as additions.
     <li> The Add, Divide and Multiply functions also exist to add, divide or multiply
       an histogram by a function.
</ul>
     If an histogram has associated error bars (TH1::Sumw2 has been called),
     the resulting error bars are also computed assuming independent histograms.
     In case of divisions, Binomial errors are also supported.
     One can mark a histogram to be an "average" histogram by setting its bit kIsAverage via
       myhist.SetBit(TH1::kIsAverage);
     When adding (see TH1::Add) average histograms, the histograms are averaged and not summed.



<h4>Fitting histograms</h4>

     Histograms (1-D, 2-D, 3-D and Profiles) can be fitted with a user
     specified function via TH1::Fit. When an histogram is fitted, the
     resulting function with its parameters is added to the list of functions
     of this histogram. If the histogram is made persistent, the list of
     associated functions is also persistent. Given a pointer (see above)
     to an associated function myfunc, one can retrieve the function/fit
     parameters with calls such as:
<pre>
       Double_t chi2 = myfunc->GetChisquare();
       Double_t par0 = myfunc->GetParameter(0); value of 1st parameter
       Double_t err0 = myfunc->GetParError(0);  error on first parameter
</pre>

<h4>Projections of histograms</h4>

<p>     One can:
<ul>
      <li> make a 1-D projection of a 2-D histogram or Profile
        see functions TH2::ProjectionX,Y, TH2::ProfileX,Y, TProfile::ProjectionX
      <li> make a 1-D, 2-D or profile out of a 3-D histogram
        see functions TH3::ProjectionZ, TH3::Project3D.
</ul>

<p>     One can fit these projections via:
<pre>
      TH2::FitSlicesX,Y, TH3::FitSlicesZ.
</pre>

<h4>Random Numbers and histograms</h4>

     TH1::FillRandom can be used to randomly fill an histogram using
                    the contents of an existing TF1 function or another
                    TH1 histogram (for all dimensions).
<p>     For example the following two statements create and fill an histogram
     10000 times with a default gaussian distribution of mean 0 and sigma 1:
<pre>
       TH1F h1("h1", "histo from a gaussian", 100, -3, 3);
       h1.FillRandom("gaus", 10000);
</pre>
     TH1::GetRandom can be used to return a random number distributed
                    according the contents of an histogram.

<h4>Making a copy of an histogram</h4>

     Like for any other ROOT object derived from TObject, one can use
     the Clone() function. This makes an identical copy of the original
     histogram including all associated errors and functions, e.g.:
<pre>
       TH1F *hnew = (TH1F*)h->Clone("hnew");
</pre>

<h4>Normalizing histograms</h4>

     One can scale an histogram such that the bins integral is equal to
     the normalization parameter via TH1::Scale(Double_t norm), where norm
     is the desired normalization divided by the integral of the histogram.

<h4>Drawing histograms</h4>

     Histograms are drawn via the THistPainter class. Each histogram has
     a pointer to its own painter (to be usable in a multithreaded program).
     Many drawing options are supported.
     See THistPainter::Paint() for more details.
<p>
    The same histogram can be drawn with different options in different pads.
     When an histogram drawn in a pad is deleted, the histogram is
     automatically removed from the pad or pads where it was drawn.
     If an histogram is drawn in a pad, then filled again, the new status
     of the histogram will be automatically shown in the pad next time
     the pad is updated. One does not need to redraw the histogram.
     To draw the current version of an histogram in a pad, one can use
<pre>
        h->DrawCopy();
</pre>
     This makes a clone (see Clone below) of the histogram. Once the clone
     is drawn, the original histogram may be modified or deleted without
     affecting the aspect of the clone.
<p>
     One can use TH1::SetMaximum() and TH1::SetMinimum() to force a particular
     value for the maximum or the minimum scale on the plot. (For 1-D
     histograms this means the y-axis, while for 2-D histograms these
     functions affect the z-axis).
<p>
     TH1::UseCurrentStyle() can be used to change all histogram graphics
     attributes to correspond to the current selected style.
     This function must be called for each histogram.
     In case one reads and draws many histograms from a file, one can force
     the histograms to inherit automatically the current graphics style
     by calling before gROOT->ForceStyle().


<h4>Setting Drawing histogram contour levels (2-D hists only)</h4>

     By default contours are automatically generated at equidistant
     intervals. A default value of 20 levels is used. This can be modified
     via TH1::SetContour() or TH1::SetContourLevel().
     the contours level info is used by the drawing options "cont", "surf",
     and "lego".

<h4>Setting histogram graphics attributes</h4>

     The histogram classes inherit from the attribute classes:
       TAttLine, TAttFill, and TAttMarker.
     See the member functions of these classes for the list of options.

<h4>Giving titles to the X, Y and Z axis</h4>
<pre>
       h->GetXaxis()->SetTitle("X axis title");
       h->GetYaxis()->SetTitle("Y axis title");
</pre>
     The histogram title and the axis titles can be any TLatex string.
     The titles are part of the persistent histogram.
     It is also possible to specify the histogram title and the axis
     titles at creation time. These titles can be given in the "title"
     parameter. They must be separated by ";":
<pre>
        TH1F* h=new TH1F("h", "Histogram title;X Axis;Y Axis;Z Axis", 100, 0, 1);
</pre>
     Any title can be omitted:
<pre>
        TH1F* h=new TH1F("h", "Histogram title;;Y Axis", 100, 0, 1);
        TH1F* h=new TH1F("h", ";;Y Axis", 100, 0, 1);
</pre>
     The method SetTitle has the same syntax:
<pre>
</pre>
        h->SetTitle("Histogram title;Another X title Axis");

<h4>Saving/Reading histograms to/from a ROOT file</h4>

     The following statements create a ROOT file and store an histogram
     on the file. Because TH1 derives from TNamed, the key identifier on
     the file is the histogram name:
<pre>
        TFile f("histos.root", "new");
        TH1F h1("hgaus", "histo from a gaussian", 100, -3, 3);
        h1.FillRandom("gaus", 10000);
        h1->Write();
</pre>
     To read this histogram in another Root session, do:
<pre>
        TFile f("histos.root");
        TH1F *h = (TH1F*)f.Get("hgaus");
</pre>
     One can save all histograms in memory to the file by:
<pre>
        file->Write();
</pre>

<h4>Miscelaneous operations</h4>

<pre>
        TH1::KolmogorovTest(): statistical test of compatibility in shape
                             between two histograms
        TH1::Smooth() smooths the bin contents of a 1-d histogram
        TH1::Integral() returns the integral of bin contents in a given bin range
        TH1::GetMean(int axis) returns the mean value along axis
        TH1::GetRMS(int axis)  returns the sigma distribution along axis
        TH1::GetEntries() returns the number of entries
        TH1::Reset() resets the bin contents and errors of an histogram
</pre>
End_Html */



TF1 *gF1=0;  //left for back compatibility (use TVirtualFitter::GetUserFunc instead)

Int_t  TH1::fgBufferSize   = 1000;
Bool_t TH1::fgAddDirectory = kTRUE;
Bool_t TH1::fgDefaultSumw2 = kFALSE;
Bool_t TH1::fgStatOverflows= kFALSE;

extern void H1InitGaus();
extern void H1InitExpo();
extern void H1InitPolynom();
extern void H1LeastSquareFit(Int_t n, Int_t m, Double_t *a);
extern void H1LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double_t &a1, Int_t &ifail);
extern void H1LeastSquareSeqnd(Int_t n, Double_t *a, Int_t idim, Int_t &ifail, Int_t k, Double_t *b);

// Internal exceptions for the CheckConsistency method
class DifferentDimension: public std::exception {};
class DifferentNumberOfBins: public std::exception {};
class DifferentAxisLimits: public std::exception {};
class DifferentBinLimits: public std::exception {};
class DifferentLabels: public std::exception {};

ClassImp(TH1)


//______________________________________________________________________________
TH1::TH1(): TNamed(), TAttLine(), TAttFill(), TAttMarker()
{
   // Histogram default constructor.

   fDirectory     = 0;
   fFunctions     = new TList;
   fNcells        = 0;
   fIntegral      = 0;
   fPainter       = 0;
   fEntries       = 0;
   fNormFactor    = 0;
   fTsumw         = fTsumw2=fTsumwx=fTsumwx2=0;
   fMaximum       = -1111;
   fMinimum       = -1111;
   fBufferSize    = 0;
   fBuffer        = 0;
   fBinStatErrOpt = kNormal;
   fXaxis.SetName("xaxis");
   fYaxis.SetName("yaxis");
   fZaxis.SetName("zaxis");
   fXaxis.SetParent(this);
   fYaxis.SetParent(this);
   fZaxis.SetParent(this);
   UseCurrentStyle();
}


//______________________________________________________________________________
TH1::~TH1()
{
   // Histogram default destructor.

   if (!TestBit(kNotDeleted)) {
      return;
   }
   delete[] fIntegral;
   fIntegral = 0;
   delete[] fBuffer;
   fBuffer = 0;
   if (fFunctions) {
      fFunctions->SetBit(kInvalidObject);
      TObject* obj = 0;
      //special logic to support the case where the same object is
      //added multiple times in fFunctions.
      //This case happens when the same object is added with different
      //drawing modes
      //In the loop below we must be careful with objects (eg TCutG) that may
      // have been added to the list of functions of several histograms
      //and may have been already deleted.
      while ((obj  = fFunctions->First())) {
         while(fFunctions->Remove(obj)) { }
         if (!obj->TestBit(kNotDeleted)) {
            break;
         }
         delete obj;
         obj = 0;
      }
      delete fFunctions;
      fFunctions = 0;
   }
   if (fDirectory) {
      fDirectory->Remove(this);
      fDirectory = 0;
   }
   delete fPainter;
   fPainter = 0;
}


//______________________________________________________________________________
TH1::TH1(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
    :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker()
{
   // Normal constructor for fix bin size histograms.
   //
   //     Creates the main histogram structure:
   //        name   : name of histogram (avoid blanks)
   //        title  : histogram title
   //                 if title is of the form "stringt;stringx;stringy;stringz"
   //                 the histogram title is set to stringt,
   //                 the x axis title to stringy, the y axis title to stringy, etc.
   //        nbins  : number of bins
   //        xlow   : low edge of first bin
   //        xup    : upper edge of last bin (not included in last bin)
   //
   //      When an histogram is created, it is automatically added to the list
   //      of special objects in the current directory.
   //      To find the pointer to this histogram in the current directory
   //      by its name, do:
   //      TH1F *h1 = (TH1F*)gDirectory->FindObject(name);

   Build();
   if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; }
   fXaxis.Set(nbins,xlow,xup);
   fNcells = fXaxis.GetNbins()+2;
}


//______________________________________________________________________________
TH1::TH1(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
    :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker()
{
   // Normal constructor for variable bin size histograms.
   //
   //  Creates the main histogram structure:
   //     name   : name of histogram (avoid blanks)
   //     title  : histogram title
   //              if title is of the form "stringt;stringx;stringy;stringz"
   //              the histogram title is set to stringt,
   //              the x axis title to stringx, the y axis title to stringy, etc.
   //     nbins  : number of bins
   //     xbins  : array of low-edges for each bin
   //              This is an array of size nbins+1

   Build();
   if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; }
   if (xbins) fXaxis.Set(nbins,xbins);
   else       fXaxis.Set(nbins,0,1);
   fNcells = fXaxis.GetNbins()+2;
}


//______________________________________________________________________________
TH1::TH1(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
    :TNamed(name,title), TAttLine(), TAttFill(), TAttMarker()
{
   // Normal constructor for variable bin size histograms.
   //
   //  Creates the main histogram structure:
   //     name   : name of histogram (avoid blanks)
   //     title  : histogram title
   //              if title is of the form "stringt;stringx;stringy;stringz"
   //              the histogram title is set to stringt,
   //              the x axis title to stringx, the y axis title to stringy, etc.
   //     nbins  : number of bins
   //     xbins  : array of low-edges for each bin
   //              This is an array of size nbins+1

   Build();
   if (nbins <= 0) {Warning("TH1","nbins is <=0 - set to nbins = 1"); nbins = 1; }
   if (xbins) fXaxis.Set(nbins,xbins);
   else       fXaxis.Set(nbins,0,1);
   fNcells = fXaxis.GetNbins()+2;
}


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

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


//______________________________________________________________________________
Bool_t TH1::AddDirectoryStatus()
{
   //static function: cannot be inlined on Windows/NT
   return fgAddDirectory;
}


//______________________________________________________________________________
void TH1::Browse(TBrowser *b)
{
   // Browe the Histogram object.

   Draw(b ? b->GetDrawOption() : "");
   gPad->Update();
}


//______________________________________________________________________________
void TH1::Build()
{
   //  Creates histogram basic data structure.

   fDirectory     = 0;
   fPainter       = 0;
   fIntegral      = 0;
   fEntries       = 0;
   fNormFactor    = 0;
   fTsumw         = fTsumw2=fTsumwx=fTsumwx2=0;
   fMaximum       = -1111;
   fMinimum       = -1111;
   fBufferSize    = 0;
   fBuffer        = 0;
   fBinStatErrOpt = kNormal;
   fXaxis.SetName("xaxis");
   fYaxis.SetName("yaxis");
   fZaxis.SetName("zaxis");
   fYaxis.Set(1,0.,1.);
   fZaxis.Set(1,0.,1.);
   fXaxis.SetParent(this);
   fYaxis.SetParent(this);
   fZaxis.SetParent(this);

   SetTitle(fTitle.Data());

   fFunctions = new TList;

   UseCurrentStyle();

   if (TH1::AddDirectoryStatus()) {
      fDirectory = gDirectory;
      if (fDirectory) {
         fDirectory->Append(this,kTRUE);
      }
   }
}


//______________________________________________________________________________
Bool_t TH1::Add(TF1 *f1, Double_t c1, Option_t *option)
{
   // Performs the operation: this = this + c1*f1
   // if errors are defined (see TH1::Sumw2), errors are also recalculated.
   //
   // By default, the function is computed at the centre of the bin.
   // if option "I" is specified (1-d histogram only), the integral of the
   // function in each bin is used instead of the value of the function at
   // the centre of the bin.
   // Only bins inside the function range are recomputed.
   // IMPORTANT NOTE: If you intend to use the errors of this histogram later
   // you should call Sumw2 before making this operation.
   // This is particularly important if you fit the histogram after TH1::Add
   //
   // The function return kFALSE if the Add operation failed

   if (!f1) {
      Error("Add","Attempt to add a non-existing function");
      return kFALSE;
   }

   TString opt = option;
   opt.ToLower();
   Bool_t integral = kFALSE;
   if (opt.Contains("i") && fDimension == 1) integral = kTRUE;

   Int_t ncellsx = GetNbinsX() + 2; // cells = normal bins + underflow bin + overflow bin
   Int_t ncellsy = GetNbinsY() + 2;
   Int_t ncellsz = GetNbinsZ() + 2;
   if (fDimension < 2) ncellsy = 1;
   if (fDimension < 3) ncellsz = 1;

   // delete buffer if it is there since it will become invalid
   if (fBuffer) BufferEmpty(1);

   //   - Add statistics
   Double_t s1[10];
   for (Int_t i = 0; i < 10; ++i) s1[i] = 0;
   PutStats(s1);
   SetMinimum();
   SetMaximum();

   //   - Loop on bins (including underflows/overflows)
   Int_t bin, binx, biny, binz;
   Double_t cu=0;
   Double_t xx[3];
   Double_t *params = 0;
   f1->InitArgs(xx,params);
   for (binz = 0; binz < ncellsz; ++binz) {
      xx[2] = fZaxis.GetBinCenter(binz);
      for (biny = 0; biny < ncellsy; ++biny) {
         xx[1] = fYaxis.GetBinCenter(biny);
         for (binx = 0; binx < ncellsx; ++binx) {
            xx[0] = fXaxis.GetBinCenter(binx);
            if (!f1->IsInside(xx)) continue;
            TF1::RejectPoint(kFALSE);
            bin = binx + ncellsx * (biny + ncellsy * binz);
            if (integral) {
               xx[0] = fXaxis.GetBinLowEdge(binx);
               cu  = c1*f1->EvalPar(xx);
               cu += c1*f1->Integral(fXaxis.GetBinLowEdge(binx), fXaxis.GetBinUpEdge(binx)) * fXaxis.GetBinWidth(binx);
            } else {
               cu  = c1*f1->EvalPar(xx);
            }
            if (TF1::RejectedPoint()) continue;
            AddBinContent(bin,cu);
         }
      }
   }

   return kTRUE;
}


//______________________________________________________________________________
Bool_t TH1::Add(const TH1 *h1, Double_t c1)
{
   // Performs the operation: this = this + c1*h1
   // if errors are defined (see TH1::Sumw2), errors are also recalculated.
   // Note that if h1 has Sumw2 set, Sumw2 is automatically called for this
   // if not already set.
   // Note also that adding histogram with labels is not supported, histogram will be
   // added merging them by bin number independently of the labels.
   // For adding histogram with labels one should use TH1::Merge
   //
   // SPECIAL CASE (Average/Efficiency histograms)
   // For histograms representing averages or efficiencies, one should compute the average
   // of the two histograms and not the sum. One can mark a histogram to be an average
   // histogram by setting its bit kIsAverage with
   //    myhist.SetBit(TH1::kIsAverage);
   // Note that the two histograms must have their kIsAverage bit set
   //
   // IMPORTANT NOTE1: If you intend to use the errors of this histogram later
   // you should call Sumw2 before making this operation.
   // This is particularly important if you fit the histogram after TH1::Add
   //
   // IMPORTANT NOTE2: if h1 has a normalisation factor, the normalisation factor
   // is used , ie  this = this + c1*factor*h1
   // Use the other TH1::Add function if you do not want this feature
   //
   // The function return kFALSE if the Add operation failed

   if (!h1) {
      Error("Add","Attempt to add a non-existing histogram");
      return kFALSE;
   }

   // delete buffer if it is there since it will become invalid
   if (fBuffer) BufferEmpty(1);

   bool useMerge = (c1 == 1. &&  !this->TestBit(kIsAverage) && !h1->TestBit(kIsAverage) );
   try {
      CheckConsistency(this,h1);
      useMerge = kFALSE;
   } catch(DifferentNumberOfBins&) {
      if (useMerge)
         Info("Add","Attempt to add histograms with different number of bins - trying to use TH1::Merge");
      else { 
         Error("Add","Attempt to add histograms with different number of bins : nbins h1 = %d , nbins h2 =  %d",GetNbinsX(), h1->GetNbinsX());      
         return kFALSE;
      }
   } catch(DifferentAxisLimits&) {
      if (useMerge) 
         Info("Add","Attempt to add histograms with different axis limits - trying to use TH1::Merge");
      else 
         Warning("Add","Attempt to add histograms with different axis limits");
   } catch(DifferentBinLimits&) {
      if (useMerge) 
         Info("Add","Attempt to add histograms with different bin limits - trying to use TH1::Merge");
      else 
         Warning("Add","Attempt to add histograms with different bin limits");
   } catch(DifferentLabels&) {      
      // in case of different labels -
      if (useMerge) 
         Info("Add","Attempt to add histograms with different labels - trying to use TH1::Merge");
      else 
         Info("Warning","Attempt to add histograms with different labels");
   }

   if (useMerge) {
      TList l;
      l.Add(const_cast<TH1*>(h1));
      auto iret = Merge(&l);
      return (iret >= 0);
   }

   //    Create Sumw2 if h1 has Sumw2 set
   if (fSumw2.fN == 0 && h1->GetSumw2N() != 0) Sumw2();

   //   - Add statistics
   Double_t entries = TMath::Abs( GetEntries() + c1 * h1->GetEntries() );

   // statistics can be preserbed only in case of positive coefficients
   // otherwise with negative c1 (histogram subtraction) one risks to get negative variances
   Bool_t resetStats = (c1 < 0);
   Double_t s1[kNstat] = {0};
   Double_t s2[kNstat] = {0};
   if (!resetStats) {
      // need to initialize to zero s1 and s2 since
      // GetStats fills only used elements depending on dimension and type
      GetStats(s1);
      h1->GetStats(s2);
   }

   SetMinimum();
   SetMaximum();

   //   - Loop on bins (including underflows/overflows)
   Double_t factor = 1;
   if (h1->GetNormFactor() != 0) factor = h1->GetNormFactor()/h1->GetSumOfWeights();;
   Double_t c1sq = c1 * c1;
   Double_t factsq = factor * factor;

   for (Int_t bin = 0; bin < fNcells; ++bin) {
      //special case where histograms have the kIsAverage bit set
      if (this->TestBit(kIsAverage) && h1->TestBit(kIsAverage)) {
         Double_t y1 = h1->RetrieveBinContent(bin);
         Double_t y2 = this->RetrieveBinContent(bin);
         Double_t e1sq = h1->GetBinErrorSqUnchecked(bin);
         Double_t e2sq = this->GetBinErrorSqUnchecked(bin);
         Double_t w1 = 1., w2 = 1.;

         // consider all special cases  when bin errors are zero
         // see http://root.cern.ch/phpBB3//viewtopic.php?f=3&t=13299
         if (e1sq) w1 = 1. / e1sq;
         else if (h1->fSumw2.fN) {
            w1 = 1.E200; // use an arbitrary huge value
            if (y1 == 0) {
               // use an estimated error from the global histogram scale
               double sf = (s2[0] != 0) ? s2[1]/s2[0] : 1;
               w1 = 1./(sf*sf);
            }
         }
         if (e2sq) w2 = 1. / e2sq;
         else if (fSumw2.fN) {
            w2 = 1.E200; // use an arbitrary huge value
            if (y2 == 0) {
               // use an estimated error from the global histogram scale
               double sf = (s1[0] != 0) ? s1[1]/s1[0] : 1;
               w2 = 1./(sf*sf);
            }
         }

         double y =  (w1*y1 + w2*y2)/(w1 + w2);
         UpdateBinContent(bin, y);
         if (fSumw2.fN) {
            double err2 =  1./(w1 + w2);
            if (err2 < 1.E-200) err2 = 0;  // to remove arbitrary value when e1=0 AND e2=0
            fSumw2.fArray[bin] = err2;
         }
      } else { // normal case of addition between histograms
         AddBinContent(bin, c1 * factor * h1->RetrieveBinContent(bin));
         if (fSumw2.fN) fSumw2.fArray[bin] += c1sq * factsq * h1->GetBinErrorSqUnchecked(bin);
      }
   }

   // update statistics (do here to avoid changes by SetBinContent)
   if (resetStats)  {
      // statistics need to be reset in case coefficient are negative
      ResetStats();
   }
   else {
      for (Int_t i=0;i<kNstat;i++) {
         if (i == 1) s1[i] += c1*c1*s2[i];
         else        s1[i] += c1*s2[i];
      }
      PutStats(s1);
      SetEntries(entries);
   }
   return kTRUE;
}


//______________________________________________________________________________
Bool_t TH1::Add(const TH1 *h1, const TH1 *h2, Double_t c1, Double_t c2)
{
   // Replace contents of this histogram by the addition of h1 and h2.
   //
   //   this = c1*h1 + c2*h2
   //   if errors are defined (see TH1::Sumw2), errors are also recalculated
   //   Note that if h1 or h2 have Sumw2 set, Sumw2 is automatically called for this
   //   if not already set.
   //   Note also that adding histogram with labels is not supported, histogram will be
   //   added merging them by bin number independently of the labels.
   //   For adding histogram ith labels one should use TH1::Merge
   //
   // SPECIAL CASE (Average/Efficiency histograms)
   // For histograms representing averages or efficiencies, one should compute the average
   // of the two histograms and not the sum. One can mark a histogram to be an average
   // histogram by setting its bit kIsAverage with
   //    myhist.SetBit(TH1::kIsAverage);
   // Note that the two histograms must have their kIsAverage bit set
   //
   // IMPORTANT NOTE: If you intend to use the errors of this histogram later
   // you should call Sumw2 before making this operation.
   // This is particularly important if you fit the histogram after TH1::Add
   //
   // ANOTHER SPECIAL CASE : h1 = h2 and c2 < 0
   // do a scaling   this = c1 * h1 / (bin Volume)
   //
   // The function returns kFALSE if the Add operation failed


   if (!h1 || !h2) {
      Error("Add","Attempt to add a non-existing histogram");
      return kFALSE;
   }

   // delete buffer if it is there since it will become invalid
   if (fBuffer) BufferEmpty(1);

   Bool_t normWidth = kFALSE;
   if (h1 == h2 && c2 < 0) {c2 = 0; normWidth = kTRUE;}

   if (h1 != h2) {
      bool useMerge = (c1 == 1. && c2 == 1. &&  !this->TestBit(kIsAverage) && !h1->TestBit(kIsAverage) );
      
      try {
         CheckConsistency(h1,h2);
         CheckConsistency(this,h1);
         useMerge = kFALSE;
      } catch(DifferentNumberOfBins&) {
         if (useMerge)
            Info("Add","Attempt to add histograms with different number of bins - trying to use TH1::Merge");
         else {
            Error("Add","Attempt to add histograms with different number of bins : nbins h1 = %d , nbins h2 =  %d",GetNbinsX(), h1->GetNbinsX());      
            return kFALSE;
         }
      } catch(DifferentAxisLimits&) {
         if (useMerge) 
            Info("Add","Attempt to add histograms with different axis limits - trying to use TH1::Merge");
         else 
            Warning("Add","Attempt to add histograms with different axis limits");
      } catch(DifferentBinLimits&) {
         if (useMerge) 
            Info("Add","Attempt to add histograms with different bin limits - trying to use TH1::Merge");
         else 
            Warning("Add","Attempt to add histograms with different bin limits");
      } catch(DifferentLabels&) {      
         // in case of different labels -
         if (useMerge) 
            Info("Add","Attempt to add histograms with different labels - trying to use TH1::Merge");
         else 
            Info("Warning","Attempt to add histograms with different labels");
      }

      if (useMerge) {
         TList l;
         // why TList takes non-const pointers ????
         l.Add(const_cast<TH1*>(h1));
         l.Add(const_cast<TH1*>(h2));
         Reset("ICE"); 
         auto iret = Merge(&l);
         return (iret >= 0);
      }
   }

   //    Create Sumw2 if h1 or h2 have Sumw2 set
   if (fSumw2.fN == 0 && (h1->GetSumw2N() != 0 || h2->GetSumw2N() != 0)) Sumw2();

   //   - Add statistics
   Double_t nEntries = TMath::Abs( c1*h1->GetEntries() + c2*h2->GetEntries() );

   // TODO remove
   // statistics can be preserved only in case of positive coefficients
   // otherwise with negative c1 (histogram subtraction) one risks to get negative variances
   // also in case of scaling with the width we cannot preserve the statistics
   Double_t s1[kNstat] = {0};
   Double_t s2[kNstat] = {0};
   Double_t s3[kNstat];


   Bool_t resetStats = (c1*c2 < 0) || normWidth;
   if (!resetStats) {
      // need to initialize to zero s1 and s2 since
      // GetStats fills only used elements depending on dimension and type
      h1->GetStats(s1);
      h2->GetStats(s2);
      for (Int_t i=0;i<kNstat;i++) {
         if (i == 1) s3[i] = c1*c1*s1[i] + c2*c2*s2[i];
         //else        s3[i] = TMath::Abs(c1)*s1[i] + TMath::Abs(c2)*s2[i];
         else        s3[i] = c1*s1[i] + c2*s2[i];
      }
   }

   SetMinimum();
   SetMaximum();

   if (normWidth) { // DEPRECATED CASE: belongs to fitting / drawing modules

      Int_t nbinsx = GetNbinsX() + 2; // normal bins + underflow, overflow
      Int_t nbinsy = GetNbinsY() + 2;
      Int_t nbinsz = GetNbinsZ() + 2;

      if (fDimension < 2) nbinsy = 1;
      if (fDimension < 3) nbinsz = 1;

      Int_t bin, binx, biny, binz;
      for (binz = 0; binz < nbinsz; ++binz) {
         Double_t wz = h1->GetZaxis()->GetBinWidth(binz);
         for (biny = 0; biny < nbinsy; ++biny) {
            Double_t wy = h1->GetYaxis()->GetBinWidth(biny);
            for (binx = 0; binx < nbinsx; ++binx) {
               Double_t wx = h1->GetXaxis()->GetBinWidth(binx);
               bin = GetBin(binx, biny, binz);
               Double_t w = wx*wy*wz;
               UpdateBinContent(bin, c1 * h1->RetrieveBinContent(bin) / w);
               if (fSumw2.fN) {
                  Double_t e1 = h1->GetBinError(bin)/w;
                  fSumw2.fArray[bin] = c1*c1*e1*e1;
               }
            }
         }
      }
   } else if (h1->TestBit(kIsAverage) && h2->TestBit(kIsAverage)) {
      for (Int_t i = 0; i < fNcells; ++i) { // loop on cells (bins including underflow / overflow)
         // special case where histograms have the kIsAverage bit set
         Double_t y1 = h1->RetrieveBinContent(i);
         Double_t y2 = h2->RetrieveBinContent(i);
         Double_t e1sq = h1->GetBinErrorSqUnchecked(i);
         Double_t e2sq = h2->GetBinErrorSqUnchecked(i);
         Double_t w1 = 1., w2 = 1.;

         // consider all special cases  when bin errors are zero
         // see http://root.cern.ch/phpBB3//viewtopic.php?f=3&t=13299
         if (e1sq) w1 = 1./ e1sq;
         else if (h1->fSumw2.fN) {
            w1 = 1.E200; // use an arbitrary huge value
            if (y1 == 0 ) { // use an estimated error from the global histogram scale
               double sf = (s1[0] != 0) ? s1[1]/s1[0] : 1;
               w1 = 1./(sf*sf);
            }
         }
         if (e2sq) w2 = 1./ e2sq;
         else if (h2->fSumw2.fN) {
            w2 = 1.E200; // use an arbitrary huge value
            if (y2 == 0) { // use an estimated error from the global histogram scale
               double sf = (s2[0] != 0) ? s2[1]/s2[0] : 1;
               w2 = 1./(sf*sf);
            }
         }

         double y =  (w1*y1 + w2*y2)/(w1 + w2);
         UpdateBinContent(i, y);
         if (fSumw2.fN) {
            double err2 =  1./(w1 + w2);
            if (err2 < 1.E-200) err2 = 0;  // to remove arbitrary value when e1=0 AND e2=0
            fSumw2.fArray[i] = err2;
         }
      }
   } else { // case of simple histogram addition
      Double_t c1sq = c1 * c1;
      Double_t c2sq = c2 * c2;
      for (Int_t i = 0; i < fNcells; ++i) { // Loop on cells (bins including underflows/overflows)
         UpdateBinContent(i, c1 * h1->RetrieveBinContent(i) + c2 * h2->RetrieveBinContent(i));
         if (fSumw2.fN) {
            fSumw2.fArray[i] = c1sq * h1->GetBinErrorSqUnchecked(i) + c2sq * h2->GetBinErrorSqUnchecked(i);
         }
      }
   }

   if (resetStats)  {
      // statistics need to be reset in case coefficient are negative
      ResetStats();
   }
   else {
      // update statistics (do here to avoid changes by SetBinContent)  FIXME remove???
      PutStats(s3);
      SetEntries(nEntries);
   }

   return kTRUE;
}


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

   AbstractMethod("AddBinContent");
}


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

   AbstractMethod("AddBinContent");
}


//______________________________________________________________________________
void TH1::AddDirectory(Bool_t add)
{
   // Sets the flag controlling the automatic add of histograms in memory
   //
   // By default (fAddDirectory = kTRUE), histograms are automatically added
   // to the list of objects in memory.
   // Note that one histogram can be removed from its support directory
   // by calling h->SetDirectory(0) or h->SetDirectory(dir) to add it
   // to the list of objects in the directory dir.
   //
   //  NOTE that this is a static function. To call it, use;
   //     TH1::AddDirectory

   fgAddDirectory = add;
}


//______________________________________________________________________________
Int_t TH1::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 reset and filled from the buffer. When the histogram is filled from the
   //             buffer the value fBuffer[0] is set to a negative number (= - number of entries)
   //             When calling with action == 0 the histogram is NOT refilled when fBuffer[0] is < 0
   //             While when calling with action = -1 the histogram is reset and ALWAYS refilled independently if
   //             the histogram was filled before. This is needed when drawing the histogram
   //
   // action =  1 histogram is filled and buffer is deleted
   //             The buffer is automatically deleted when filling the histogram and the entries is
   //             larger than the buffer size
   //

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

   // nbentries correspond to the number of entries of histogram

   if (nbentries == 0) {
      // if action is 1 we delete the buffer
      // this will avoid infinite recursion
      if (action > 0) {
         delete [] fBuffer;
         fBuffer = 0;
         fBufferSize = 0;
      }         
      return 0;      
   }
   if (nbentries < 0 && action == 0) return 0;    // case histogram has been already filled from the buffer

   Double_t *buffer = fBuffer;
   if (nbentries < 0) {
      nbentries  = -nbentries;
      //  a reset might call BufferEmpty() giving an infinite recursion
      // Protect it by setting fBuffer = 0
      fBuffer=0;
       //do not reset the list of functions
      Reset("ICES");
      fBuffer = buffer;
   }
   if (CanExtendAllAxes() || (fXaxis.GetXmax() <= fXaxis.GetXmin())) {
      //find min, max of entries in buffer
      Double_t xmin = fBuffer[2];
      Double_t xmax = xmin;
      for (Int_t i=1;i<nbentries;i++) {
         Double_t x = fBuffer[2*i+2];
         if (x < xmin) xmin = x;
         if (x > xmax) xmax = x;
      }
      if (fXaxis.GetXmax() <= fXaxis.GetXmin()) {
         THLimitsFinder::GetLimitsFinder()->FindGoodLimits(this,xmin,xmax);
      } else {
         fBuffer = 0;
         Int_t keep = fBufferSize; fBufferSize = 0;
         if (xmin <  fXaxis.GetXmin()) ExtendAxis(xmin,&fXaxis);
         if (xmax >= fXaxis.GetXmax()) ExtendAxis(xmax,&fXaxis);
         fBuffer = buffer;
         fBufferSize = keep;
      }
   }

   // call DoFillN which will not put entries in the buffer as FillN does
   // set fBuffer to zero to avoid re-emptying the buffer from functions called
   // by DoFillN (e.g Sumw2)
   buffer = fBuffer; fBuffer = 0; 
   DoFillN(nbentries,&buffer[2],&buffer[1],2);
   fBuffer = buffer; 

   // if action == 1 - delete the buffer
   if (action > 0) {
      delete [] fBuffer;
      fBuffer = 0;
      fBufferSize = 0;}
   else {
      // if number of entries is consistent with buffer - set it negative to avoid
      // refilling the histogram every time BufferEmpty(0) is called
      // In case it is not consistent, by setting fBuffer[0]=0 is like resetting the buffer
      // (it will not be used anymore the next time BufferEmpty is called)
      if (nbentries == (Int_t)fEntries)
         fBuffer[0] = -nbentries;
      else
         fBuffer[0] = 0;
   }
   return nbentries;
}


//______________________________________________________________________________
Int_t TH1::BufferFill(Double_t x, 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

   if (!fBuffer) return -2;
   Int_t nbentries = (Int_t)fBuffer[0];


   if (nbentries < 0) {
      // reset nbentries to a positive value so next time BufferEmpty()  is called
      // the histogram will be refilled
      nbentries  = -nbentries;
      fBuffer[0] =  nbentries;
      if (fEntries > 0) {
         // set fBuffer to zero to avoid calling BufferEmpty in Reset
         Double_t *buffer = fBuffer; fBuffer=0;
         Reset("ICES");  // do not reset list of functions
         fBuffer = buffer;
      }
   }
   if (2*nbentries+2 >= fBufferSize) {
      BufferEmpty(1);
      if (!fBuffer) 
         // to avoid infinite recursion Fill->BufferFill->Fill
         return Fill(x,w);
      // this cannot happen
      R__ASSERT(0); 
   }
   fBuffer[2*nbentries+1] = w;
   fBuffer[2*nbentries+2] = x;
   fBuffer[0] += 1;
   return -2;
}


//______________________________________________________________________________
bool TH1::CheckBinLimits(const TAxis* a1, const TAxis * a2)
{

   const TArrayD * h1Array = a1->GetXbins();
   const TArrayD * h2Array = a2->GetXbins();
   Int_t fN = h1Array->fN;
   if ( fN != 0 ) {
      if ( h2Array->fN != fN ) {
         throw DifferentBinLimits();
         return false;
      }
      else {
         for ( int i = 0; i < fN; ++i ) {
            if ( ! TMath::AreEqualRel( h1Array->GetAt(i), h2Array->GetAt(i), 1E-10 ) ) {
               throw DifferentBinLimits();
               return false;
            }
         }
      }
   }

   return true;
}


//______________________________________________________________________________
bool TH1::CheckBinLabels(const TAxis* a1, const TAxis * a2)
{
   // check that axis have same labels
   THashList *l1 = a1->GetLabels();
   THashList *l2 = a2->GetLabels();

   if (!l1 && !l2 )
      return true;
   if (!l1 ||  !l2 ) {
      throw DifferentLabels();
      return false;
   }
   // check now labels sizes  are the same
   if (l1->GetSize() != l2->GetSize() ) {
      throw DifferentLabels();
      return false;
   }
   for (int i = 1; i <= a1->GetNbins(); ++i) {
      TString label1 = a1->GetBinLabel(i);
      TString label2 = a2->GetBinLabel(i);
      if (label1 != label2) {
         throw DifferentLabels();
         return false;
      }
   }

   return true;
}


//______________________________________________________________________________
bool TH1::CheckAxisLimits(const TAxis *a1, const TAxis *a2 )
{
   // Check that the axis limits of the histograms are the same
   // if a first and last bin is passed the axis is compared between the given range

   if ( ! TMath::AreEqualRel(a1->GetXmin(), a2->GetXmin(),1.E-12) ||
        ! TMath::AreEqualRel(a1->GetXmax(), a2->GetXmax(),1.E-12) ) {
      throw DifferentAxisLimits();
      return false;
   }
   return true;
}


//______________________________________________________________________________
bool TH1::CheckEqualAxes(const TAxis *a1, const TAxis *a2 )
{
   // Check that the axis are the same

   if (a1->GetNbins() != a2->GetNbins() ) {
      //throw DifferentNumberOfBins();
      ::Info("CheckEqualAxes","Axes have different number of bins : nbin1 = %d nbin2 = %d",a1->GetNbins(),a2->GetNbins() );
      return false;
   }
   try {
      CheckAxisLimits(a1,a2);
   } catch (DifferentAxisLimits&) {
      ::Info("CheckEqualAxes","Axes have different limits");
      return false;
   }
   try {
      CheckBinLimits(a1,a2);
   } catch (DifferentBinLimits&) {
      ::Info("CheckEqualAxes","Axes have different bin limits");
      return false;
   }

   // check labels
   try {
      CheckBinLabels(a1,a2);
   } catch (DifferentLabels&) {
      ::Info("CheckEqualAxes","Axes have different labels");
      return false;
   }

   return true;
}


//______________________________________________________________________________
bool TH1::CheckConsistentSubAxes(const TAxis *a1, Int_t firstBin1, Int_t lastBin1, const TAxis * a2, Int_t firstBin2, Int_t lastBin2 )
{
   // Check that two sub axis are the same
   // the limits are defined by first bin and last bin
   // N.B. no check is done in this case for variable bins

   // By default is assumed that no bins are given for the second axis
   Int_t nbins1   = lastBin1-firstBin1 + 1;
   Double_t xmin1 = a1->GetBinLowEdge(firstBin1);
   Double_t xmax1 = a1->GetBinUpEdge(lastBin1);

   Int_t nbins2 = a2->GetNbins();
   Double_t xmin2 = a2->GetXmin();
   Double_t xmax2 = a2->GetXmax();

   if (firstBin2 <  lastBin2) {
      // in this case assume no bins are given for the second axis
      nbins2   = lastBin1-firstBin1 + 1;
      xmin2 = a1->GetBinLowEdge(firstBin1);
      xmax2 = a1->GetBinUpEdge(lastBin1);
   }

   if (nbins1 != nbins2 ) {
      ::Info("CheckConsistentSubAxes","Axes have different number of bins");
      return false;
   }

   if ( ! TMath::AreEqualRel(xmin1,xmin2,1.E-12) ||
        ! TMath::AreEqualRel(xmax1,xmax2,1.E-12) ) {
      ::Info("CheckConsistentSubAxes","Axes have different limits");
      return false;
   }

   return true;
}


//______________________________________________________________________________
bool TH1::CheckConsistency(const TH1* h1, const TH1* h2)
{
   // Check histogram compatibility
   if (h1 == h2) return true;

   if (h1->GetDimension() != h2->GetDimension() ) {
      throw DifferentDimension();
      return false;
   }
   Int_t dim = h1->GetDimension();

   // returns kTRUE if number of bins and bin limits are identical
   Int_t nbinsx = h1->GetNbinsX();
   Int_t nbinsy = h1->GetNbinsY();
   Int_t nbinsz = h1->GetNbinsZ();

   // Check whether the histograms have the same number of bins.
   if (nbinsx != h2->GetNbinsX() ||
       (dim > 1 && nbinsy != h2->GetNbinsY())  ||
       (dim > 2 && nbinsz != h2->GetNbinsZ()) ) {
      throw DifferentNumberOfBins();
      return false;
   }

   bool ret = true;

   // check axis limits
   ret &= CheckAxisLimits(h1->GetXaxis(), h2->GetXaxis());
   if (dim > 1) ret &= CheckAxisLimits(h1->GetYaxis(), h2->GetYaxis());
   if (dim > 2) ret &= CheckAxisLimits(h1->GetZaxis(), h2->GetZaxis());

   // check bin limits
   ret &= CheckBinLimits(h1->GetXaxis(), h2->GetXaxis());
   if (dim > 1) ret &= CheckBinLimits(h1->GetYaxis(), h2->GetYaxis());
   if (dim > 2) ret &= CheckBinLimits(h1->GetZaxis(), h2->GetZaxis());

   // check labels if histograms are both not empty
   if ( (h1->fTsumw != 0 || h1->GetEntries() != 0) &&
        (h2->fTsumw != 0 || h2->GetEntries() != 0) ) {
      ret &= CheckBinLabels(h1->GetXaxis(), h2->GetXaxis());
      if (dim > 1) ret &= CheckBinLabels(h1->GetYaxis(), h2->GetYaxis());
      if (dim > 2) ret &= CheckBinLabels(h1->GetZaxis(), h2->GetZaxis());
   }

   return ret;
}


//______________________________________________________________________________
Double_t TH1::Chi2Test(const TH1* h2, Option_t *option, Double_t *res) const
{
   // Begin_Latex #chi^{2} End_Latex test for comparing weighted and unweighted histograms
   //
   // Function: Returns p-value. Other return values are specified by the 3rd parameter <br>
   //
   // Parameters:
   //
   //    - h2: the second histogram
   //    - option:
   //       o "UU" = experiment experiment comparison (unweighted-unweighted)
   //       o "UW" = experiment MC comparison (unweighted-weighted). Note that
   //          the first histogram should be unweighted
   //       o "WW" = MC MC comparison (weighted-weighted)
   //       o "NORM" = to be used when one or both of the histograms is scaled
   //                  but the histogram originally was unweighted
   //       o by default underflows and overlows are not included:
   //          * "OF" = overflows included
   //          * "UF" = underflows included
   //       o "P" = print chi2, ndf, p_value, igood
   //       o "CHI2" = returns chi2 instead of p-value
   //       o "CHI2/NDF" = returns Begin_Latex #chi^{2}/ndf End_Latex
   //    - res: not empty - computes normalized residuals and returns them in
   //      this array
   //
   // The current implementation is based on the papers Begin_Latex #chi^{2} End_Latex test for comparison
   // of weighted and unweighted histograms" in Proceedings of PHYSTAT05 and
   // "Comparison weighted and unweighted histograms", arXiv:physics/0605123
   // by N.Gagunashvili. This function has been implemented by Daniel Haertl in August 2006.
   //
   // Introduction:
   //
   //   A frequently used technique in data analysis is the comparison of
   //   histograms. First suggested by Pearson [1] the Begin_Latex #chi^{2} End_Latex test of
   //   homogeneity is used widely for comparing usual (unweighted) histograms.
   //   This paper describes the implementation modified Begin_Latex #chi^{2} End_Latex tests
   //   for comparison of weighted and unweighted  histograms and two weighted
   //   histograms [2] as well as usual Pearson's Begin_Latex #chi^{2} End_Latex test for
   //   comparison two usual (unweighted) histograms.
   //
   // Overview:
   //
   //   Comparison of two histograms expect hypotheses that two histograms
   //   represent identical distributions. To make a decision p-value should
   //   be calculated. The hypotheses of identity is rejected if the p-value is
   //   lower then some significance level. Traditionally significance levels
   //   0.1, 0.05 and 0.01 are used. The comparison procedure should include an
   //   analysis of the residuals which is often helpful in identifying the
   //   bins of histograms responsible for a significant overall Begin_Latex #chi^{2} End_Latex value.
   //   Residuals are the difference between bin contents and expected bin
   //   contents. Most convenient for analysis are the normalized residuals. If
   //   hypotheses of identity are valid then normalized residuals are
   //   approximately independent and identically distributed random variables
   //   having N(0,1) distribution. Analysis of residuals expect test of above
   //   mentioned properties of residuals. Notice that indirectly the analysis
   //   of residuals increase the power of Begin_Latex #chi^{2} End_Latex test.
   //
   // Methods of comparison:
   //
   //  Begin_Latex #chi^{2} End_Latex test for comparison two (unweighted) histograms:
   //   Let us consider two  histograms with the  same binning and the  number
   //   of bins equal to r. Let us denote the number of events in the ith bin
   //   in the first histogram as ni and as mi in the second one. The total
   //   number of events in the first histogram is equal to:
   //Begin_Latex
   //   N = #sum_{i=1}^{r} n_{i}
   //End_Latex
   //   and
   //Begin_Latex
   //   M = #sum_{i=1}^{r} m_{i}
   //End_Latex
   //   in the second histogram. The hypothesis of identity (homogeneity) [3]
   //   is that the two histograms represent random values with identical
   //   distributions. It is equivalent that there exist r constants p1,...,pr,
   //   such that
   //Begin_Latex
   //   #sum_{i=1}^{r} p_{i}=1
   //End_Latex
   //    and the probability of belonging to the ith bin for some measured value
   //    in both experiments is equal to pi. The number of events in the ith
   //    bin is a random variable with a distribution approximated by a Poisson
   //    probability distribution
   //Begin_Latex
   //   #frac{e^{-Np_{i}}(Np_{i})^{n_{i}}}{n_{i}!}
   //End_Latex
   //   for the first histogram and with distribution
   //Begin_Latex
   //   #frac{e^{-Mp_{i}}(Mp_{i})^{m_{i}}}{m_{i}!}
   //End_Latex
   //   for the second histogram. If the hypothesis of homogeneity is valid,
   //   then the  maximum likelihood estimator of pi, i=1,...,r, is
   //Begin_Latex
   //   #hat{p}_{i}= #frac{n_{i}+m_{i}}{N+M}
   //End_Latex
   //   and then
   //Begin_Latex
   //   X^{2} = #sum_{i=1}^{r}#frac{(n_{i}-N#hat{p}_{i})^{2}}{N#hat{p}_{i}} + #sum_{i=1}^{r}#frac{(m_{i}-M#hat{p}_{i})^{2}}{M#hat{p}_{i}} = #frac{1}{MN} #sum_{i=1}^{r}#frac{(Mn_{i}-Nm_{i})^{2}}{n_{i}+m_{i}}
   //End_Latex
   //   has approximately a Begin_Latex #chi^{2}_{(r-1)} End_Latex distribution [3].
   //   The comparison procedure can include an analysis of the residuals which
   //   is often helpful in identifying the bins of histograms responsible for
   //   a significant overall Begin_Latex #chi^{2} End_Latexvalue. Most convenient for
   //   analysis are the adjusted (normalized) residuals [4]
   //Begin_Latex
   //   r_{i} = #frac{n_{i}-N#hat{p}_{i}}{#sqrt{N#hat{p}_{i}}#sqrt{(1-N/(N+M))(1-(n_{i}+m_{i})/(N+M))}}
   //End_Latex
   //   If hypotheses of  homogeneity are valid then residuals ri are
   //   approximately independent and identically distributed random variables
   //   having N(0,1) distribution. The application of the Begin_Latex #chi^{2} End_latex test has
   //   restrictions related to the value of the expected frequencies Npi,
   //   Mpi, i=1,...,r. A conservative rule formulated in [5] is that all the
   //   expectations must be 1 or greater for both histograms. In practical
   //   cases when expected frequencies are not known the estimated expected
   //   frequencies Begin_Latex M#hat{p}_{i}, N#hat{p}_{i}, i=1,...,r End_Latex  can be used.
   //
   //  Unweighted and weighted histograms comparison:
   //
   //   A simple modification of the ideas described above can be used for the
   //   comparison of the usual (unweighted) and weighted histograms. Let us
   //   denote the number of events in the ith bin in the unweighted
   //   histogram as ni and the common weight of events in the ith bin of the
   //   weighted histogram as wi. The total number of events in the
   //   unweighted histogram is equal to
   //Begin_Latex
   //   N = #sum_{i=1}^{r} n_{i}
   //End_Latex
   //   and the total weight of events in the weighted histogram is equal to
   //Begin_Latex
   //   W = #sum_{i=1}^{r} w_{i}
   //End_Latex
   //   Let us formulate the hypothesis of identity of an unweighted histogram
   //   to a weighted histogram so that there exist r constants p1,...,pr, such
   //   that
   //Begin_Latex
   //   #sum_{i=1}^{r} p_{i} = 1
   //End_Latex
   //   for the unweighted histogram. The weight wi is a random variable with a
   //   distribution approximated by the normal probability distribution
   //   Begin_Latex N(Wp_{i},#sigma_{i}^{2}) End_Latex where Begin_Latex #sigma_{i}^{2} End_Latex is the variance of the weight wi.
   //   If we replace the variance Begin_Latex #sigma_{i}^{2} End_Latex
   //   with estimate Begin_Latex s_{i}^{2} End_Latex (sum of squares of weights of
   //   events in the ith bin) and the hypothesis of identity is valid, then the
   //   maximum likelihood estimator of  pi,i=1,...,r, is
   //Begin_Latex
   //   #hat{p}_{i} = #frac{Ww_{i}-Ns_{i}^{2}+#sqrt{(Ww_{i}-Ns_{i}^{2})^{2}+4W^{2}s_{i}^{2}n_{i}}}{2W^{2}}
   //End_Latex
   //   We may then use the test statistic
   //Begin_Latex
   //   X^{2} = #sum_{i=1}^{r} #frac{(n_{i}-N#hat{p}_{i})^{2}}{N#hat{p}_{i}} + #sum_{i=1}^{r} #frac{(w_{i}-W#hat{p}_{i})^{2}}{s_{i}^{2}}
   //End_Latex
   //   and it has approximately a Begin_Latex #chi^{2}_{(r-1)} End_Latex distribution [2]. This test, as well
   //   as the original one [3], has a restriction on the expected frequencies. The
   //   expected frequencies recommended for the weighted histogram is more than 25.
   //   The value of the minimal expected frequency can be decreased down to 10 for
   //   the case when the weights of the events are close to constant. In the case
   //   of a weighted histogram if the number of events is unknown, then we can
   //   apply this recommendation for the equivalent number of events as
   //Begin_Latex
   //   n_{i}^{equiv} = #frac{ w_{i}^{2} }{ s_{i}^{2} }
   //End_Latex
   //   The minimal expected frequency for an unweighted histogram must be 1. Notice
   //   that any usual (unweighted) histogram can be considered as a weighted
   //   histogram with events that have constant weights equal to 1.
   //   The variance Begin_Latex z_{i}^{2} End_Latex of the difference between the weight wi
   //   and the estimated expectation value of the weight is approximately equal to:
   //Begin_Latex
   //   z_{i}^{2} = Var(w_{i}-W#hat{p}_{i}) = N#hat{p}_{i}(1-N#hat{p}_{i})#left(#frac{Ws_{i}^{2}}{#sqrt{(Ns_{i}^{2}-w_{i}W)^{2}+4W^{2}s_{i}^{2}n_{i}}}#right)^{2}+#frac{s_{i}^{2}}{4}#left(1+#frac{Ns_{i}^{2}-w_{i}W}{#sqrt{(Ns_{i}^{2}-w_{i}W)^{2}+4W^{2}s_{i}^{2}n_{i}}}#right)^{2}
   //End_Latex
   //   The  residuals
   //Begin_Latex
   //   r_{i} = #frac{w_{i}-W#hat{p}_{i}}{z_{i}}
   //End_Latex
   //   have approximately a normal distribution with mean equal to 0 and standard
   //   deviation  equal to 1.
   //
   //  Two weighted histograms comparison:
   //
   //   Let us denote the common  weight of events of the ith bin in the first
   //   histogram as w1i and as w2i in the second one. The total weight of events
   //   in the first histogram is equal to
   //Begin_Latex
   //   W_{1} = #sum_{i=1}^{r} w_{1i}
   //End_Latex
   //   and
   //Begin_Latex
   //   W_{2} = #sum_{i=1}^{r} w_{2i}
   //End_Latex
   //   in the second histogram. Let us formulate the hypothesis of identity of
   //   weighted histograms so that there exist r constants p1,...,pr, such that
   //Begin_Latex
   //   #sum_{i=1}^{r} p_{i} = 1
   //End_Latex
   //   and also expectation value of weight w1i equal to W1pi and expectation value
   //   of weight w2i equal to W2pi. Weights in both the histograms are random
   //   variables with distributions which can be approximated by a normal
   //   probability distribution Begin_Latex N(W_{1}p_{i},#sigma_{1i}^{2}) End_Latex for the first histogram
   //   and by a distribution Begin_Latex N(W_{2}p_{i},#sigma_{2i}^{2}) End_Latex for the second.
   //   Here Begin_Latex #sigma_{1i}^{2} End_Latex and Begin_Latex #sigma_{2i}^{2} End_Latex are the variances
   //   of w1i and w2i with estimators Begin_Latex s_{1i}^{2} End_Latex and Begin_Latex s_{2i}^{2} End_Latex respectively.
   //   If the hypothesis of identity is valid, then the maximum likelihood and
   //   Least Square Method estimator of pi,i=1,...,r, is
   //Begin_Latex
   //   #hat{p}_{i} = #frac{w_{1i}W_{1}/s_{1i}^{2}+w_{2i}W_{2} /s_{2i}^{2}}{W_{1}^{2}/s_{1i}^{2}+W_{2}^{2}/s_{2i}^{2}}
   //End_Latex
   //   We may then use the test statistic
   //Begin_Latex
   //   X^{2} = #sum_{i=1}^{r} #frac{(w_{1i}-W_{1}#hat{p}_{i})^{2}}{s_{1i}^{2}} + #sum_{i=1}^{r} #frac{(w_{2i}-W_{2}#hat{p}_{i})^{2}}{s_{2i}^{2}} = #sum_{i=1}^{r} #frac{(W_{1}w_{2i}-W_{2}w_{1i})^{2}}{W_{1}^{2}s_{2i}^{2}+W_{2}^{2}s_{1i}^{2}}
   //End_Latex
   //   and it has approximately a Begin_Latex #chi^{2}_{(r-1)} End_Latex distribution [2].
   //   The normalized or studentised residuals [6]
   //Begin_Latex
   //   r_{i} = #frac{w_{1i}-W_{1}#hat{p}_{i}}{s_{1i}#sqrt{1 - #frac{1}{(1+W_{2}^{2}s_{1i}^{2}/W_{1}^{2}s_{2i}^{2})}}}
   //End_Latex
   //   have approximately a normal distribution with mean equal to 0 and standard
   //   deviation 1. A recommended minimal expected frequency is equal to 10 for
   //   the proposed test.
   //
   // Numerical examples:
   //
   //   The method described herein is now illustrated with an example.
   //   We take a distribution
   //Begin_Latex
   //   #phi(x) = #frac{2}{(x-10)^{2}+1} + #frac{1}{(x-14)^{2}+1}       (1)
   //End_Latex
   //   defined on the interval [4,16]. Events distributed according to the formula
   //   (1) are simulated to create the unweighted histogram. Uniformly distributed
   //   events are simulated for the weighted histogram with weights calculated by
   //   formula (1). Each histogram has the same number of bins: 20. Fig.1 shows
   //   the result of comparison of the unweighted histogram with 200 events
   //   (minimal expected frequency equal to one) and the weighted histogram with
   //   500 events (minimal expected frequency equal to 25)
   //Begin_Macro
   // ../../../tutorials/math/chi2test.C
   //End_Macro
   //   Fig 1. An example of comparison of the unweighted histogram with 200 events
   //   and the weighted histogram with 500 events:
   //      a) unweighted histogram;
   //      b) weighted histogram;
   //      c) normalized residuals plot;
   //      d) normal Q-Q plot of residuals.
   //
   //   The value of the test statistic Begin_Latex #chi^{2} End_Latex is equal to
   //   21.09 with p-value equal to 0.33, therefore the hypothesis of identity of
   //   the two histograms can be accepted for 0.05 significant level. The behavior
   //   of the normalized residuals plot (see Fig. 1c) and the normal Q-Q plot
   //   (see Fig. 1d) of residuals are regular and we cannot identify the outliers
   //   or bins with a big influence on Begin_Latex #chi^{2} End_Latex.
   //
   //   The second example presents the same two histograms but 17 events was added
   //   to content of bin number 15 in unweighted histogram. Fig.2 shows the result
   //   of comparison of the unweighted histogram with 217 events (minimal expected
   //   frequency equal to one) and the weighted histogram with 500 events (minimal
   //   expected frequency equal to 25)
   //Begin_Macro
   // ../../../tutorials/math/chi2test.C(17)
   //End_Macro
   //   Fig 2. An example of comparison of the unweighted histogram with 217 events
   //   and the weighted histogram with 500 events:
   //      a) unweighted histogram;
   //      b) weighted histogram;
   //      c) normalized residuals plot;
   //      d) normal Q-Q plot of residuals.
   //
   //   The value of the test statistic Begin_Latex #chi^{2} End_Latex is equal to
   //   32.33 with p-value equal to 0.029, therefore the hypothesis of identity of
   //   the two histograms is rejected for 0.05 significant level. The behavior of
   //   the normalized residuals plot (see Fig. 2c) and the normal Q-Q plot (see
   //   Fig. 2d) of residuals are not regular and we can identify the outlier or
   //   bin with a big influence on Begin_Latex #chi^{2} End_Latex.
   //
   // References:
   //
   // [1] Pearson, K., 1904. On the Theory of Contingency and Its Relation to
   //     Association and Normal Correlation. Drapers' Co. Memoirs, Biometric
   //     Series No. 1, London.
   // [2] Gagunashvili, N., 2006. Begin_Latex #chi^{2} End_Latex test for comparison
   //     of weighted and unweighted histograms. Statistical Problems in Particle
   //     Physics, Astrophysics and Cosmology, Proceedings of PHYSTAT05,
   //     Oxford, UK, 12-15 September 2005, Imperial College Press, London, 43-44.
   //     Gagunashvili,N., Comparison of weighted and unweighted histograms,
   //     arXiv:physics/0605123, 2006.
   // [3] Cramer, H., 1946. Mathematical methods of statistics.
   //     Princeton University Press, Princeton.
   // [4] Haberman, S.J., 1973. The analysis of residuals in cross-classified tables.
   //     Biometrics 29, 205-220.
   // [5] Lewontin, R.C. and Felsenstein, J., 1965. The robustness of homogeneity
   //     test in 2xN tables. Biometrics 21, 19-33.
   // [6] Seber, G.A.F., Lee, A.J., 2003, Linear Regression Analysis.
   //     John Wiley & Sons Inc., New York.

   Double_t chi2 = 0;
   Int_t ndf = 0, igood = 0;

   TString opt = option;
   opt.ToUpper();

   Double_t prob = Chi2TestX(h2,chi2,ndf,igood,option,res);

   if(opt.Contains("P")) {
      printf("Chi2 = %f, Prob = %g, NDF = %d, igood = %d\n", chi2,prob,ndf,igood);
   }
   if(opt.Contains("CHI2/NDF")) {
      if (ndf == 0) return 0;
      return chi2/ndf;
   }
   if(opt.Contains("CHI2")) {
      return chi2;
   }

   return prob;
}


//______________________________________________________________________________
Double_t TH1::Chi2TestX(const TH1* h2,  Double_t &chi2, Int_t &ndf, Int_t &igood, Option_t *option,  Double_t *res) const
{
   // The computation routine of the Chisquare test. For the method description,
   // see Chi2Test() function.
   // Returns p-value
   // parameters:
   //  - h2-second histogram
   //  - option:
   //     "UU" = experiment experiment comparison (unweighted-unweighted)
   //     "UW" = experiment MC comparison (unweighted-weighted). Note that the first
   //           histogram should be unweighted
   //     "WW" = MC MC comparison (weighted-weighted)
   //
   //     "NORM" = if one or both histograms is scaled
   //
   //     "OF" = overflows included
   //     "UF" = underflows included
   //         by default underflows and overflows are not included
   //
   //  - igood:
   //       igood=0 - no problems
   //        For unweighted unweighted  comparison
   //       igood=1'There is a bin in the 1st histogram with less than 1 event'
   //       igood=2'There is a bin in the 2nd histogram with less than 1 event'
   //       igood=3'when the conditions for igood=1 and igood=2 are satisfied'
   //        For  unweighted weighted  comparison
   //       igood=1'There is a bin in the 1st histogram with less then 1 event'
   //       igood=2'There is a bin in the 2nd histogram with less then 10 effective number of events'
   //       igood=3'when the conditions for igood=1 and igood=2 are satisfied'
   //        For  weighted weighted  comparison
   //       igood=1'There is a bin in the 1st  histogram with less then 10 effective
   //        number of events'
   //       igood=2'There is a bin in the 2nd  histogram with less then 10 effective
   //               number of events'
   //       igood=3'when the conditions for igood=1 and igood=2 are satisfied'
   //
   //  - chi2 - chisquare of the test
   //  - ndf  - number of degrees of freedom (important, when both histograms have the same
   //         empty bins)
   //  - res -  normalized residuals for further analysis


   Int_t i_start, i_end;
   Int_t j_start, j_end;
   Int_t k_start, k_end;

   Double_t sum1 = 0.0, sumw1 = 0.0;
   Double_t sum2 = 0.0, sumw2 = 0.0;

   chi2 = 0.0;
   ndf = 0;

   TString opt = option;
   opt.ToUpper();

   if (fBuffer) const_cast<TH1*>(this)->BufferEmpty();

   const TAxis *xaxis1 = GetXaxis();
   const TAxis *xaxis2 = h2->GetXaxis();
   const TAxis *yaxis1 = GetYaxis();
   const TAxis *yaxis2 = h2->GetYaxis();
   const TAxis *zaxis1 = GetZaxis();
   const TAxis *zaxis2 = h2->GetZaxis();

   Int_t nbinx1 = xaxis1->GetNbins();
   Int_t nbinx2 = xaxis2->GetNbins();
   Int_t nbiny1 = yaxis1->GetNbins();
   Int_t nbiny2 = yaxis2->GetNbins();
   Int_t nbinz1 = zaxis1->GetNbins();
   Int_t nbinz2 = zaxis2->GetNbins();

   //check dimensions
   if (this->GetDimension() != h2->GetDimension() ){
      Error("Chi2TestX","Histograms have different dimensions.");
      return 0.0;
   }

   //check number of channels
   if (nbinx1 != nbinx2) {
      Error("Chi2TestX","different number of x channels");
   }
   if (nbiny1 != nbiny2) {
      Error("Chi2TestX","different number of y channels");
   }
   if (nbinz1 != nbinz2) {
      Error("Chi2TestX","different number of z channels");
   }

   //check for ranges
   i_start = j_start = k_start = 1;
   i_end = nbinx1;
   j_end = nbiny1;
   k_end = nbinz1;

   if (xaxis1->TestBit(TAxis::kAxisRange)) {
      i_start = xaxis1->GetFirst();
      i_end   = xaxis1->GetLast();
   }
   if (yaxis1->TestBit(TAxis::kAxisRange)) {
      j_start = yaxis1->GetFirst();
      j_end   = yaxis1->GetLast();
   }
   if (zaxis1->TestBit(TAxis::kAxisRange)) {
      k_start = zaxis1->GetFirst();
      k_end   = zaxis1->GetLast();
   }


   if (opt.Contains("OF")) {
      if (GetDimension() == 3) k_end = ++nbinz1;
      if (GetDimension() >= 2) j_end = ++nbiny1;
      if (GetDimension() >= 1) i_end = ++nbinx1;
   }

   if (opt.Contains("UF")) {
      if (GetDimension() == 3) k_start = 0;
      if (GetDimension() >= 2) j_start = 0;
      if (GetDimension() >= 1) i_start = 0;
   }

   ndf = (i_end - i_start + 1) * (j_end - j_start + 1) * (k_end - k_start + 1) - 1;

   Bool_t comparisonUU = opt.Contains("UU");
   Bool_t comparisonUW = opt.Contains("UW");
   Bool_t comparisonWW = opt.Contains("WW");
   Bool_t scaledHistogram  = opt.Contains("NORM");

   if (scaledHistogram && !comparisonUU) {
      Info("Chi2TestX", "NORM option should be used together with UU option. It is ignored");
   }

   // look at histo global bin content and effective entries
   Stat_t s[kNstat];
   GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights
   Double_t sumBinContent1 = s[0];
   Double_t effEntries1 = (s[1] ? s[0] * s[0] / s[1] : 0.0);

   h2->GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights
   Double_t sumBinContent2 = s[0];
   Double_t effEntries2 = (s[1] ? s[0] * s[0] / s[1] : 0.0);

   if (!comparisonUU && !comparisonUW && !comparisonWW ) {
      // deduce automatically from type of histogram
      if (TMath::Abs(sumBinContent1 - effEntries1) < 1) {
         if ( TMath::Abs(sumBinContent2 - effEntries2) < 1) comparisonUU = true;
         else comparisonUW = true;
      }
      else comparisonWW = true;
   }
   // check unweighted histogram
   if (comparisonUW) {
      if (TMath::Abs(sumBinContent1 - effEntries1) >= 1) {
         Warning("Chi2TestX","First histogram is not unweighted and option UW has been requested");
      }
   }
   if ( (!scaledHistogram && comparisonUU)   ) {
      if ( ( TMath::Abs(sumBinContent1 - effEntries1) >= 1) || (TMath::Abs(sumBinContent2 - effEntries2) >= 1) ) {
         Warning("Chi2TestX","Both histograms are not unweighted and option UU has been requested");
      }
   }


   //get number of events in histogram
   if (comparisonUU && scaledHistogram) {
      for (Int_t i = i_start; i <= i_end; ++i) {
         for (Int_t j = j_start; j <= j_end; ++j) {
            for (Int_t k = k_start; k <= k_end; ++k) {

               Int_t bin = GetBin(i, j, k);

               Double_t cnt1 = RetrieveBinContent(bin);
               Double_t cnt2 = h2->RetrieveBinContent(bin);
               Double_t e1sq = GetBinErrorSqUnchecked(bin);
               Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);

               if (e1sq > 0.0) cnt1 = TMath::Floor(cnt1 * cnt1 / e1sq + 0.5); // avoid rounding errors
               else cnt1 = 0.0;

               if (e2sq > 0.0) cnt2 = TMath::Floor(cnt2 * cnt2 / e2sq + 0.5); // avoid rounding errors
               else cnt2 = 0.0;

               // sum contents
               sum1 += cnt1;
               sum2 += cnt2;
               sumw1 += e1sq;
               sumw2 += e2sq;
            }
         }
      }
      if (sumw1 <= 0.0 || sumw2 <= 0.0) {
         Error("Chi2TestX", "Cannot use option NORM when one histogram has all zero errors");
         return 0.0;
      }

   } else {
      for (Int_t i = i_start; i <= i_end; ++i) {
         for (Int_t j = j_start; j <= j_end; ++j) {
            for (Int_t k = k_start; k <= k_end; ++k) {

               Int_t bin = GetBin(i, j, k);

               sum1 += RetrieveBinContent(bin);
               sum2 += h2->RetrieveBinContent(bin);

               if ( comparisonWW ) sumw1 += GetBinErrorSqUnchecked(bin);
               if ( comparisonUW || comparisonWW ) sumw2 += h2->GetBinErrorSqUnchecked(bin);
            }
         }
      }
   }
   //checks that the histograms are not empty
   if (sum1 == 0.0 || sum2 == 0.0) {
      Error("Chi2TestX","one histogram is empty");
      return 0.0;
   }

   if ( comparisonWW  && ( sumw1 <= 0.0 && sumw2 <= 0.0 ) ){
      Error("Chi2TestX","Hist1 and Hist2 have both all zero errors\n");
      return 0.0;
   }

   //THE TEST
   Int_t m = 0, n = 0;

   //Experiment - experiment comparison
   if (comparisonUU) {
      Double_t sum = sum1 + sum2;
      for (Int_t i = i_start; i <= i_end; ++i) {
         for (Int_t j = j_start; j <= j_end; ++j) {
            for (Int_t k = k_start; k <= k_end; ++k) {

               Int_t bin = GetBin(i, j, k);

               Double_t cnt1 = RetrieveBinContent(bin);
               Double_t cnt2 = h2->RetrieveBinContent(bin);

               if (scaledHistogram) {
                  // scale bin value to effective bin entries
                  Double_t e1sq = GetBinErrorSqUnchecked(bin);
                  Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);

                  if (e1sq > 0) cnt1 = TMath::Floor(cnt1 * cnt1 / e1sq + 0.5); // avoid rounding errors
                  else cnt1 = 0;

                  if (e2sq > 0) cnt2 = TMath::Floor(cnt2 * cnt2 / e2sq + 0.5); // avoid rounding errors
                  else cnt2 = 0;
               }

               if (Int_t(cnt1) == 0 && Int_t(cnt2) == 0) --ndf;  // no data means one degree of freedom less
               else {

                  Double_t cntsum = cnt1 + cnt2;
                  Double_t nexp1 = cntsum * sum1 / sum;
                  //Double_t nexp2 = binsum*sum2/sum;

                  if (res) res[i - i_start] = (cnt1 - nexp1) / TMath::Sqrt(nexp1);

                  if (cnt1 < 1) ++m;
                  if (cnt2 < 1) ++n;

                  //Habermann correction for residuals
                  Double_t correc = (1. - sum1 / sum) * (1. - cntsum / sum);
                  if (res) res[i - i_start] /= TMath::Sqrt(correc);

                  Double_t delta = sum2 * cnt1 - sum1 * cnt2;
                  chi2 += delta * delta / cntsum;
               }
            }
         }
      }
      chi2 /= sum1 * sum2;

      // flag error only when of the two histogram is zero
      if (m) {
         igood += 1;
         Info("Chi2TestX","There is a bin in h1 with less than 1 event.\n");
      }
      if (n) {
         igood += 2;
         Info("Chi2TestX","There is a bin in h2 with less than 1 event.\n");
      }

      Double_t prob = TMath::Prob(chi2,ndf);
      return prob;

   }

   // unweighted - weighted  comparison
   // case of error = 0 and content not zero is treated without problems by excluding second chi2 sum
   // and can be considered as a data-theory comparison
   if ( comparisonUW ) {
      for (Int_t i = i_start; i <= i_end; ++i) {
         for (Int_t j = j_start; j <= j_end; ++j) {
            for (Int_t k = k_start; k <= k_end; ++k) {

               Int_t bin = GetBin(i, j, k);

               Double_t cnt1 = RetrieveBinContent(bin);
               Double_t cnt2 = h2->RetrieveBinContent(bin);
               Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);

               // case both histogram have zero bin contents
               if (cnt1 * cnt1 == 0 && cnt2 * cnt2 == 0) {
                  --ndf;  //no data means one degree of freedom less
                  continue;
               }

               // case weighted histogram has zero bin content and error
               if (cnt2 * cnt2 == 0 && e2sq == 0) {
                  if (sumw2 > 0) {
                     // use as approximated  error as 1 scaled by a scaling ratio
                     // estimated from the total sum weight and sum weight squared
                     e2sq = sumw2 / sum2;
                  }
                  else {
                     // return error because infinite discrepancy here:
                     // bin1 != 0 and bin2 =0 in a histogram with all errors zero
                     Error("Chi2TestX","Hist2 has in bin (%d,%d,%d) zero content and zero errors\n", i, j, k);
                     chi2 = 0; return 0;
                  }
               }

               if (cnt1 < 1) m++;
               if (e2sq > 0 && cnt2 * cnt2 / e2sq < 10) n++;

               Double_t var1 = sum2 * cnt2 - sum1 * e2sq;
               Double_t var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;

               // if cnt1 is zero and cnt2 = 1 and sum1 = sum2 var1 = 0 && var2 == 0
               // approximate by incrementing cnt1
               // LM (this need to be fixed for numerical errors)
               while (var1 * var1 + cnt1 == 0 || var1 + var2 == 0) {
                  sum1++;
                  cnt1++;
                  var1 = sum2 * cnt2 - sum1 * e2sq;
                  var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
               }
               var2 = TMath::Sqrt(var2);

               while (var1 + var2 == 0) {
                  sum1++;
                  cnt1++;
                  var1 = sum2 * cnt2 - sum1 * e2sq;
                  var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
                  while (var1 * var1 + cnt1 == 0 || var1 + var2 == 0) {
                     sum1++;
                     cnt1++;
                     var1 = sum2 * cnt2 - sum1 * e2sq;
                     var2 = var1 * var1 + 4. * sum2 * sum2 * cnt1 * e2sq;
                  }
                  var2 = TMath::Sqrt(var2);
               }

               Double_t probb = (var1 + var2) / (2. * sum2 * sum2);

               Double_t nexp1 = probb * sum1;
               Double_t nexp2 = probb * sum2;

               Double_t delta1 = cnt1 - nexp1;
               Double_t delta2 = cnt2 - nexp2;

               chi2 += delta1 * delta1 / nexp1;

               if (e2sq > 0) {
                  chi2 += delta2 * delta2 / e2sq;
               }

               if (res) {
                  if (e2sq > 0) {
                     Double_t temp1 = sum2 * e2sq / var2;
                     Double_t temp2 = 1.0 + (sum1 * e2sq - sum2 * cnt2) / var2;
                     temp2 = temp1 * temp1 * sum1 * probb * (1.0 - probb) + temp2 * temp2 * e2sq / 4.0;
                     // invert sign here
                     res[i - i_start] = - delta2 / TMath::Sqrt(temp2);
                  }
                  else
                     res[i - i_start] = delta1 / TMath::Sqrt(nexp1);
               }
            }
         }
      }

      if (m) {
         igood += 1;
         Info("Chi2TestX","There is a bin in h1 with less than 1 event.\n");
      }
      if (n) {
         igood += 2;
         Info("Chi2TestX","There is a bin in h2 with less than 10 effective events.\n");
      }

      Double_t prob = TMath::Prob(chi2, ndf);

      return prob;
   }

   // weighted - weighted  comparison
   if (comparisonWW) {
      for (Int_t i = i_start; i <= i_end; ++i) {
         for (Int_t j = j_start; j <= j_end; ++j) {
            for (Int_t k = k_start; k <= k_end; ++k) {

               Int_t bin = GetBin(i, j, k);
               Double_t cnt1 = RetrieveBinContent(bin);
               Double_t cnt2 = h2->RetrieveBinContent(bin);
               Double_t e1sq = GetBinErrorSqUnchecked(bin);
               Double_t e2sq = h2->GetBinErrorSqUnchecked(bin);

               // case both histogram have zero bin contents
               // (use square of content to avoid numerical errors)
                if (cnt1 * cnt1 == 0 && cnt2 * cnt2 == 0) {
                   --ndf;  //no data means one degree of freedom less
                   continue;
                }

                if (e1sq == 0 && e2sq == 0) {
                   // cannot treat case of booth histogram have zero zero errors
                  Error("Chi2TestX","h1 and h2 both have bin %d,%d,%d with all zero errors\n", i,j,k);
                  chi2 = 0; return 0;
               }

               Double_t sigma = sum1 * sum1 * e2sq + sum2 * sum2 * e1sq;
               Double_t delta = sum2 * cnt1 - sum1 * cnt2;
               chi2 += delta * delta / sigma;

               if (res) {
                  Double_t temp = cnt1 * sum1 * e2sq + cnt2 * sum2 * e1sq;
                  Double_t probb = temp / sigma;
                  Double_t z = 0;
                  if (e1sq > e2sq) {
                     Double_t d1 = cnt1 - sum1 * probb;
                     Double_t s1 = e1sq * ( 1. - e2sq * sum1 * sum1 / sigma );
                     z = d1 / TMath::Sqrt(s1);
                  }
                  else {
                     Double_t d2 = cnt2 - sum2 * probb;
                     Double_t s2 = e2sq * ( 1. - e1sq * sum2 * sum2 / sigma );
                     z = -d2 / TMath::Sqrt(s2);
                  }
                  res[i - i_start] = z;
               }

               if (e1sq > 0 && cnt1 * cnt1 / e1sq < 10) m++;
               if (e2sq > 0 && cnt2 * cnt2 / e2sq < 10) n++;
            }
         }
      }
      if (m) {
         igood += 1;
         Info("Chi2TestX","There is a bin in h1 with less than 10 effective events.\n");
      }
      if (n) {
         igood += 2;
         Info("Chi2TestX","There is a bin in h2 with less than 10 effective events.\n");
      }
      Double_t prob = TMath::Prob(chi2, ndf);
      return prob;
   }
   return 0;
}
//______________________________________________________________________________
Double_t TH1::Chisquare(TF1 * func, Option_t *option) const
{
   // Compute and return the chisquare of this histogram with respect to a function
   // The chisquare is computed by weighting each histogram point by the bin error
   // By default the full range of the histogram is used.
   // Use option "R" for restricting the chisquare calculation to the given range of the function

   if (!func) {
      Error("Chisquare","Function pointer is Null - return -1");
      return -1;
   }

   TString opt(option); opt.ToUpper();
   bool useRange = opt.Contains("R");

   return ROOT::Fit::Chisquare(*this, *func, useRange);
}

//______________________________________________________________________________
void TH1::ClearUnderflowAndOverflow()
{
   // Remove all the content from the underflow and overflow bins, without changing the number of entries
   // After calling this method, every undeflow and overflow bins will have content 0.0
   // The Sumw2 is also cleared, since there is no more content in the bins
   for (Int_t bin = 0; bin < fNcells; ++bin)
      if (IsBinUnderflow(bin) || IsBinOverflow(bin)) {
         UpdateBinContent(bin, 0.0);
         if (fSumw2.fN) fSumw2.fArray[bin] = 0.0;
      }
}

//______________________________________________________________________________
Double_t TH1::ComputeIntegral(Bool_t onlyPositive)
{
   //  Compute integral (cumulative sum of bins)
   //  The result stored in fIntegral is used by the GetRandom functions.
   //  This function is automatically called by GetRandom when the fIntegral
   //  array does not exist or when the number of entries in the histogram
   //  has changed since the previous call to GetRandom.
   //  The resulting integral is normalized to 1
   //  If the routine is called with the onlyPositive flag set an error will
   //  be produced in case of negative bin content and a NaN value returned

   if (fBuffer) BufferEmpty();

   // delete previously computed integral (if any)
   if (fIntegral) delete [] fIntegral;

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

   fIntegral = new Double_t[nbins + 2];
   Int_t ibin = 0; fIntegral[ibin] = 0;

   for (Int_t binz=1; binz <= nbinsz; ++binz) {
      for (Int_t biny=1; biny <= nbinsy; ++biny) {
         for (Int_t binx=1; binx <= nbinsx; ++binx) {
            ++ibin;
            Double_t y = RetrieveBinContent(GetBin(binx, biny, binz));
            if (onlyPositive && y < 0) {
                 Error("ComputeIntegral","Bin content is negative - return a NaN value");
                 fIntegral[nbins] = TMath::QuietNaN();
                 break;
             }
            fIntegral[ibin] = fIntegral[ibin - 1] + y;
         }
      }
   }

   //   - Normalize integral to 1
   if (fIntegral[nbins] == 0 ) {
      Error("ComputeIntegral", "Integral = zero"); return 0;
   }
   for (Int_t bin=1; bin <= nbins; ++bin)  fIntegral[bin] /= fIntegral[nbins];
   fIntegral[nbins+1] = fEntries;
   return fIntegral[nbins];
}


//______________________________________________________________________________
Double_t *TH1::GetIntegral()
{
   //  Return a pointer to the array of bins integral.
   //  if the pointer fIntegral is null, TH1::ComputeIntegral is called
   // The array dimension is the number of bins in the histograms
   // including underflow and overflow (fNCells)
   // the last value integral[fNCells] is set to the number of entries of
   // the histogram

   if (!fIntegral) ComputeIntegral();
   return fIntegral;
}


//______________________________________________________________________________
TH1 *TH1::GetCumulative(Bool_t forward, const char* suffix) const
{
   //  Return a pointer to an histogram containing the cumulative The
   //  cumulative can be computed both in the forward (default) or backward
   //  direction; the name of the new histogram is constructed from
   //  the name of this histogram with the suffix suffix appended.
   //
   // The cumulative distribution is formed by filling each bin of the
   // resulting histogram with the sum of that bin and all previous
   // (forward == kTRUE) or following (forward = kFALSE) bins.
   //
   // note: while cumulative distributions make sense in one dimension, you
   // may not be getting what you expect in more than 1D because the concept
   // of a cumulative distribution is much trickier to define; make sure you
   // understand the order of summation before you use this method with
   // histograms of dimension >= 2.

   const Int_t nbinsx = GetNbinsX();
   const Int_t nbinsy = GetNbinsY();
   const Int_t nbinsz = GetNbinsZ();
   TH1* hintegrated = (TH1*) Clone(fName + suffix);
   hintegrated->Reset();
   if (forward) { // Forward computation
      Double_t sum = 0.;
      for (Int_t binz = 1; binz <= nbinsz; ++binz) {
	 for (Int_t biny = 1; biny <= nbinsy; ++biny) {
	    for (Int_t binx = 1; binx <= nbinsx; ++binx) {
	       const Int_t bin = hintegrated->GetBin(binx, biny, binz);
	       sum += GetBinContent(bin);
	       hintegrated->SetBinContent(bin, sum);
	    }
	 }
      }
   } else { // Backward computation
      Double_t sum = 0.;
      for (Int_t binz = nbinsz; binz >= 1; --binz) {
	 for (Int_t biny = nbinsy; biny >= 1; --biny) {
	    for (Int_t binx = nbinsx; binx >= 1; --binx) {
	       const Int_t bin = hintegrated->GetBin(binx, biny, binz);
	       sum += GetBinContent(bin);
	       hintegrated->SetBinContent(bin, sum);
	    }
	 }
      }
   }
   return hintegrated;
}

//______________________________________________________________________________
void TH1::Copy(TObject &obj) const
{
   // Copy this histogram structure to newth1.
   //
   // Note that this function does not copy the list of associated functions.
   // Use TObject::Clone to make a full copy of an histogram.

   if (((TH1&)obj).fDirectory) {
      // We are likely to change the hash value of this object
      // with TNamed::Copy, to keep things correct, we need to
      // clean up its existing entries.
      ((TH1&)obj).fDirectory->Remove(&obj);
      ((TH1&)obj).fDirectory = 0;
   }
   TNamed::Copy(obj);
   ((TH1&)obj).fDimension = fDimension;
   ((TH1&)obj).fNormFactor= fNormFactor;
   ((TH1&)obj).fNcells    = fNcells;
   ((TH1&)obj).fBarOffset = fBarOffset;
   ((TH1&)obj).fBarWidth  = fBarWidth;
   ((TH1&)obj).fOption    = fOption;
   ((TH1&)obj).fBufferSize= fBufferSize;
   // copy the Buffer
   // delete first a previously existing buffer
   if (((TH1&)obj).fBuffer != 0)  {
      delete []  ((TH1&)obj).fBuffer;
      ((TH1&)obj).fBuffer = 0;
   }
   if (fBuffer) {
      Double_t *buf = new Double_t[fBufferSize];
      for (Int_t i=0;i<fBufferSize;i++) buf[i] = fBuffer[i];
      // obj.fBuffer has been deleted before
      ((TH1&)obj).fBuffer    = buf;
   }


   TArray* a = dynamic_cast<TArray*>(&obj);
   if (a) a->Set(fNcells);
   for (Int_t i = 0; i < fNcells; i++) ((TH1&)obj).UpdateBinContent(i, RetrieveBinContent(i));

   ((TH1&)obj).fEntries   = fEntries;

   // which will call BufferEmpty(0) and set fBuffer[0] to a  Maybe one should call
   // assignment operator on the TArrayD

   ((TH1&)obj).fTsumw     = fTsumw;
   ((TH1&)obj).fTsumw2    = fTsumw2;
   ((TH1&)obj).fTsumwx    = fTsumwx;
   ((TH1&)obj).fTsumwx2   = fTsumwx2;
   ((TH1&)obj).fMaximum   = fMaximum;
   ((TH1&)obj).fMinimum   = fMinimum;

   TAttLine::Copy(((TH1&)obj));
   TAttFill::Copy(((TH1&)obj));
   TAttMarker::Copy(((TH1&)obj));
   fXaxis.Copy(((TH1&)obj).fXaxis);
   fYaxis.Copy(((TH1&)obj).fYaxis);
   fZaxis.Copy(((TH1&)obj).fZaxis);
   ((TH1&)obj).fXaxis.SetParent(&obj);
   ((TH1&)obj).fYaxis.SetParent(&obj);
   ((TH1&)obj).fZaxis.SetParent(&obj);
   fContour.Copy(((TH1&)obj).fContour);
   fSumw2.Copy(((TH1&)obj).fSumw2);
   //   fFunctions->Copy(((TH1&)obj).fFunctions);
   if (fgAddDirectory && gDirectory) {
      gDirectory->Append(&obj);
      ((TH1&)obj).fDirectory = gDirectory;
   }

}


//______________________________________________________________________________
TObject* TH1::Clone(const char* newname) const
{
   // Make a clone of an object bur for performance we are not using the
   // Streamer facility for TH1 and derived.  Instead we rely on the
   // (required) implementation of Copy.

   TH1* obj = (TH1*)IsA()->GetNew()(0);
   Copy(*obj);

   //Now handle the parts that Copy doesn't do
   if (fFunctions) {
      obj->fFunctions = (TList*)fFunctions->Clone();
   }
   if (newname && newname[0]) {
      obj->SetName(newname);
   }
   return obj;
}

//______________________________________________________________________________
void TH1::DirectoryAutoAdd(TDirectory *dir)
{
   // Perform the automatic addition of the histogram to the given directory
   //
   // Note this function is called in place when the semantic requires
   // this object to be added to a directory (I.e. when being read from
   // a TKey or being Cloned)
   //

   Bool_t addStatus = TH1::AddDirectoryStatus();
   if (addStatus) {
      SetDirectory(dir);
      if (dir) {
         ResetBit(kCanDelete);
      }
   }
}


//______________________________________________________________________________
Int_t TH1::DistancetoPrimitive(Int_t px, Int_t py)
{
   // Compute distance from point px,py to a line.
   //
   //     Compute the closest distance of approach from point px,py to elements
   //     of an histogram.
   //     The distance is computed in pixels units.
   //
   //     Algorithm:
   //     Currently, this simple model computes the distance from the mouse
   //     to the histogram contour only.

   if (!fPainter) return 9999;
   return fPainter->DistancetoPrimitive(px,py);
}


//______________________________________________________________________________
Bool_t TH1::Divide(TF1 *f1, Double_t c1)
{
   // Performs the operation: this = this/(c1*f1)
   // if errors are defined (see TH1::Sumw2), errors are also recalculated.
   //
   // Only bins inside the function range are recomputed.
   // IMPORTANT NOTE: If you intend to use the errors of this histogram later
   // you should call Sumw2 before making this operation.
   // This is particularly important if you fit the histogram after TH1::Divide
   //
   // The function return kFALSE if the divide operation failed

   if (!f1) {
      Error("Add","Attempt to divide by a non-existing function");
      return kFALSE;
   }

   // delete buffer if it is there since it will become invalid
   if (fBuffer) BufferEmpty(1);

   Int_t nx = GetNbinsX() + 2; // normal bins + uf / of
   Int_t ny = GetNbinsY() + 2;
   Int_t nz = GetNbinsZ() + 2;
   if (fDimension < 2) ny = 1;
   if (fDimension < 3) nz = 1;


   SetMinimum();
   SetMaximum();

   //   - Loop on bins (including underflows/overflows)
   Int_t bin, binx, biny, binz;
   Double_t cu, w;
   Double_t xx[3];
   Double_t *params = 0;
   f1->InitArgs(xx,params);
   for (binz = 0; binz < nz; ++binz) {
      xx[2] = fZaxis.GetBinCenter(binz);
      for (biny = 0; biny < ny; ++biny) {
         xx[1] = fYaxis.GetBinCenter(biny);
         for (binx = 0; binx < nx; ++binx) {
            xx[0] = fXaxis.GetBinCenter(binx);
            if (!f1->IsInside(xx)) continue;
            TF1::RejectPoint(kFALSE);
            bin = binx + nx * (biny + ny * binz);
            cu  = c1 * f1->EvalPar(xx);
            if (TF1::RejectedPoint()) continue;
            if (cu) w = RetrieveBinContent(bin) / cu;
            else    w = 0;
            UpdateBinContent(bin, w);
            if (fSumw2.fN) {
               if (cu != 0) fSumw2.fArray[bin] = GetBinErrorSqUnchecked(bin) / (cu * cu);
               else         fSumw2.fArray[bin] = 0;
            }
         }
      }
   }
   ResetStats();
   return kTRUE;
}


//______________________________________________________________________________
Bool_t TH1::Divide(const TH1 *h1)
{
   // Divide this histogram by h1.
   //
   //   this = this/h1
   //   if errors are defined (see TH1::Sumw2), errors are also recalculated.
   //   Note that if h1 has Sumw2 set, Sumw2 is automatically called for this
   //   if not already set.
   //   The resulting errors are calculated assuming uncorrelated histograms.
   //   See the other TH1::Divide that gives the possibility to optionally
   //   compute binomial errors.
   //
   // IMPORTANT NOTE: If you intend to use the errors of this histogram later
   // you should call Sumw2 before making this operation.
   // This is particularly important if you fit the histogram after TH1::Scale
   //
   // The function return kFALSE if the divide operation failed

   if (!h1) {
      Error("Divide", "Input histogram passed does not exist (NULL).");
      return kFALSE;
   }

   // delete buffer if it is there since it will become invalid
   if (fBuffer) BufferEmpty(1);

   try {
      CheckConsistency(this,h1);
   } catch(DifferentNumberOfBins&) {
      Error("Divide","Cannot divide histograms with different number of bins");
      return kFALSE;
   } catch(DifferentAxisLimits&) {
      Warning("Divide","Dividing histograms with different axis limits");
   } catch(DifferentBinLimits&) {
      Warning("Divide","Dividing histograms with different bin limits");
   } catch(DifferentLabels&) {
      Warning("Divide","Dividing histograms with different labels");
   }

   //    Create Sumw2 if h1 has Sumw2 set
   if (fSumw2.fN == 0 && h1->GetSumw2N() != 0) Sumw2();

   //   - Loop on bins (including underflows/overflows)
   for (Int_t i = 0; i < fNcells; ++i) {
      Double_t c0 = RetrieveBinContent(i);
      Double_t c1 = h1->RetrieveBinContent(i);
      if (c1) UpdateBinContent(i, c0 / c1);
      else UpdateBinContent(i, 0);

      if(fSumw2.fN) {
         if (c1 == 0) { fSumw2.fArray[i] = 0; continue; }
         Double_t c1sq = c1 * c1;
         fSumw2.fArray[i] = (GetBinErrorSqUnchecked(i) * c1sq + h1->GetBinErrorSqUnchecked(i) * c0 * c0) / (c1sq * c1sq);
      }
   }
   ResetStats();
   return kTRUE;
}


//______________________________________________________________________________
Bool_t TH1::Divide(const TH1 *h1, const TH1 *h2, Double_t c1, Double_t c2, Option_t *option)
{
   // Replace contents of this histogram by the division of h1 by h2.
   //
   //   this = c1*h1/(c2*h2)
   //
   //   if errors are defined (see TH1::Sumw2), errors are also recalculated
   //   Note that if h1 or h2 have Sumw2 set, Sumw2 is automatically called for this
   //   if not already set.
   //   The resulting errors are calculated assuming uncorrelated histograms.
   //   However, if option ="B" is specified, Binomial errors are computed.
   //   In this case c1 and c2 do not make real sense and they are ignored.
   //
   // IMPORTANT NOTE: If you intend to use the errors of this histogram later
   // you should call Sumw2 before making this operation.
   // This is particularly important if you fit the histogram after TH1::Divide
   //
   //  Please note also that in the binomial case errors are calculated using standard
   //  binomial statistics, which means when b1 = b2, the error is zero.
   //  If you prefer to have efficiency errors not going to zero when the efficiency is 1, you must
   //  use the function TGraphAsymmErrors::BayesDivide, which will return an asymmetric and non-zero lower
   //  error for the case b1=b2.
   //
   // The function return kFALSE if the divide operation failed


   TString opt = option;
   opt.ToLower();
   Bool_t binomial = kFALSE;
   if (opt.Contains("b")) binomial = kTRUE;
   if (!h1 || !h2) {
      Error("Divide", "At least one of the input histograms passed does not exist (NULL).");
      return kFALSE;
   }

   // delete buffer if it is there since it will become invalid
   if (fBuffer) BufferEmpty(1);

   try {
      CheckConsistency(h1,h2);
      CheckConsistency(this,h1);
   } catch(DifferentNumberOfBins&) {
      Error("Divide","Cannot divide histograms with different number of bins");
      return kFALSE;
   } catch(DifferentAxisLimits&) {
      Warning("Divide","Dividing histograms with different axis limits");
   } catch(DifferentBinLimits&) {
      Warning("Divide","Dividing histograms with different bin limits");
   }  catch(DifferentLabels&) {
      Warning("Divide","Dividing histograms with different labels");
   }


   if (!c2) {
      Error("Divide","Coefficient of dividing histogram cannot be zero");
      return kFALSE;
   }

   //    Create Sumw2 if h1 or h2 have Sumw2 set
   if (fSumw2.fN == 0 && (h1->GetSumw2N() != 0 || h2->GetSumw2N() != 0)) Sumw2();

   SetMinimum();
   SetMaximum();

   //   - Loop on bins (including underflows/overflows)
   for (Int_t i = 0; i < fNcells; ++i) {
      Double_t b1 = h1->RetrieveBinContent(i);
      Double_t b2 = h2->RetrieveBinContent(i);
      if (b2) UpdateBinContent(i, c1 * b1 / (c2 * b2));
      else UpdateBinContent(i, 0);

      if (fSumw2.fN) {
         if (b2 == 0) { fSumw2.fArray[i] = 0; continue; }
         Double_t b1sq = b1 * b1; Double_t b2sq = b2 * b2;
         Double_t c1sq = c1 * c1; Double_t c2sq = c2 * c2;
         Double_t e1sq = h1->GetBinErrorSqUnchecked(i);
         Double_t e2sq = h2->GetBinErrorSqUnchecked(i);
         if (binomial) {
            if (b1 != b2) {
               // in the case of binomial statistics c1 and c2 must be 1 otherwise it does not make sense
               // c1 and c2 are ignored
               //fSumw2.fArray[bin] = TMath::Abs(w*(1-w)/(c2*b2));//this is the formula in Hbook/Hoper1
               //fSumw2.fArray[bin] = TMath::Abs(w*(1-w)/b2);     // old formula from G. Flucke
               // formula which works also for weighted histogram (see http://root.cern.ch/phpBB2/viewtopic.php?t=3753 )
               fSumw2.fArray[i] = TMath::Abs( ( (1. - 2.* b1 / b2) * e1sq  + b1sq * e2sq / b2sq ) / b2sq );
            } else {
               //in case b1=b2 error is zero
               //use  TGraphAsymmErrors::BayesDivide for getting the asymmetric error not equal to zero
               fSumw2.fArray[i] = 0;
            }
         } else {
            fSumw2.fArray[i] = c1sq * c2sq * (e1sq * b2sq + e2sq * b1sq) / (c2sq * c2sq * b2sq * b2sq);
         }
      }
   }
   ResetStats();
   if (binomial)
      // in case of binomial division use denominator for number of entries
      SetEntries ( h2->GetEntries() );

   return kTRUE;
}


//______________________________________________________________________________
void TH1::Draw(Option_t *option)
{
   // Draw this histogram with options.
   //
   // Histograms are drawn via the THistPainter class. Each histogram has
   // a pointer to its own painter (to be usable in a multithreaded program).
   // The same histogram can be drawn with different options in different pads.
   // When an histogram drawn in a pad is deleted, the histogram is
   // automatically removed from the pad or pads where it was drawn.
   // If an histogram is drawn in a pad, then filled again, the new status
   // of the histogram will be automatically shown in the pad next time
   // the pad is updated. One does not need to redraw the histogram.
   // To draw the current version of an histogram in a pad, one can use
   //      h->DrawCopy();
   // This makes a clone of the histogram. Once the clone is drawn, the original
   // histogram may be modified or deleted without affecting the aspect of the
   // clone.
   // By default, TH1::Draw clears the current pad.
   //
   // One can use TH1::SetMaximum and TH1::SetMinimum to force a particular
   // value for the maximum or the minimum scale on the plot.
   //
   // TH1::UseCurrentStyle can be used to change all histogram graphics
   // attributes to correspond to the current selected style.
   // This function must be called for each histogram.
   // In case one reads and draws many histograms from a file, one can force
   // the histograms to inherit automatically the current graphics style
   // by calling before gROOT->ForceStyle();
   //
   // See the THistPainter class for a description of all the drawing options.

   TString opt1 = option; opt1.ToLower();
   TString opt2 = option;
   Int_t index  = opt1.Index("same");

   // Check if the string "same" is part of a TCutg name.
   if (index>=0) {
      Int_t indb = opt1.Index("[");
      if (indb>=0) {
         Int_t indk = opt1.Index("]");
         if (index>indb && index<indk) index = -1;
      }
   }

   // If there is no pad or an empty pad the the "same" is ignored.
   if (gPad) {
      if (!gPad->IsEditable()) gROOT->MakeDefCanvas();
      if (index>=0) {
         if (gPad->GetX1() == 0   && gPad->GetX2() == 1 &&
             gPad->GetY1() == 0   && gPad->GetY2() == 1 &&
             gPad->GetListOfPrimitives()->GetSize()==0) opt2.Remove(index,4);
      } else {
         //the following statement is necessary in case one attempts to draw
         //a temporary histogram already in the current pad
         if (TestBit(kCanDelete)) gPad->GetListOfPrimitives()->Remove(this);
         gPad->Clear();
      }
   } else {
      if (index>=0) opt2.Remove(index,4);
   }

   AppendPad(opt2.Data());
}


//______________________________________________________________________________
TH1 *TH1::DrawCopy(Option_t *option, const char * name_postfix) const
{
   // Copy this histogram and Draw in the current pad.
   //
   //     Once the histogram is drawn into the pad, any further modification
   //     using graphics input will be made on the copy of the histogram,
   //     and not to the original object.
   //     By default a postfix "_copy" is added to the histogram name. Pass an empty postfix in case 
   //     you want to draw an histogram with the same name
   //
   //     See Draw for the list of options

   TString opt = option;
   opt.ToLower();
   if (gPad && !opt.Contains("same")) gPad->Clear();
   TString newName = (name_postfix) ?  TString::Format("%s%s",GetName(),name_postfix) : "";
   TH1 *newth1 = (TH1 *)Clone(newName);
   newth1->SetDirectory(0);
   newth1->SetBit(kCanDelete);
   newth1->AppendPad(option);
   return newth1;
}


//______________________________________________________________________________
TH1 *TH1::DrawNormalized(Option_t *option, Double_t norm) const
{
   //  Draw a normalized copy of this histogram.
   //
   //  A clone of this histogram is normalized to norm and drawn with option.
   //  A pointer to the normalized histogram is returned.
   //  The contents of the histogram copy are scaled such that the new
   //  sum of weights (excluding under and overflow) is equal to norm.
   //  Note that the returned normalized histogram is not added to the list
   //  of histograms in the current directory in memory.
   //  It is the user's responsability to delete this histogram.
   //  The kCanDelete bit is set for the returned object. If a pad containing
   //  this copy is cleared, the histogram will be automatically deleted.
   //
   //     See Draw for the list of options

   Double_t sum = GetSumOfWeights();
   if (sum == 0) {
      Error("DrawNormalized","Sum of weights is null. Cannot normalize histogram: %s",GetName());
      return 0;
   }
   Bool_t addStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);
   TH1 *h = (TH1*)Clone();
   h->SetBit(kCanDelete);
   // in case of drawing with error options - scale correctly the error
   TString opt(option); opt.ToUpper();
   if (fSumw2.fN == 0) {
      h->Sumw2();
      // do not use in this case the "Error option " for drawing which is enabled by default since the normalized histogram has now errors
      if (opt.IsNull() || opt == "SAME") opt += "HIST";
   }
   h->Scale(norm/sum);
   if (TMath::Abs(fMaximum+1111) > 1e-3) h->SetMaximum(fMaximum*norm/sum);
   if (TMath::Abs(fMinimum+1111) > 1e-3) h->SetMinimum(fMinimum*norm/sum);
   h->Draw(opt);
   TH1::AddDirectory(addStatus);
   return h;
}


//______________________________________________________________________________
void TH1::DrawPanel()
{
   // Display a panel with all histogram drawing options.
   //
   //      See class TDrawPanelHist for example

   if (!fPainter) {Draw(); if (gPad) gPad->Update();}
   if (fPainter) fPainter->DrawPanel();
}


//______________________________________________________________________________
void TH1::Eval(TF1 *f1, Option_t *option)
{
   // Evaluate function f1 at the center of bins of this histogram.
   //
   //     If option "R" is specified, the function is evaluated only
   //     for the bins included in the function range.
   //     If option "A" is specified, the value of the function is added to the
   //     existing bin contents
   //     If option "S" is specified, the value of the function is used to
   //     generate a value, distributed according to the Poisson
   //     distribution, with f1 as the mean.

   Double_t x[3];
   Int_t range, stat, add;
   if (!f1) return;

   TString opt = option;
   opt.ToLower();
   if (opt.Contains("a")) add   = 1;
   else                   add   = 0;
   if (opt.Contains("s")) stat  = 1;
   else                   stat  = 0;
   if (opt.Contains("r")) range = 1;
   else                   range = 0;

   // delete buffer if it is there since it will become invalid
   if (fBuffer) BufferEmpty(1);

   Int_t nbinsx  = fXaxis.GetNbins();
   Int_t nbinsy  = fYaxis.GetNbins();
   Int_t nbinsz  = fZaxis.GetNbins();
   if (!add) Reset();

   for (Int_t binz = 1; binz <= nbinsz; ++binz) {
      x[2]  = fZaxis.GetBinCenter(binz);
      for (Int_t biny = 1; biny <= nbinsy; ++biny) {
         x[1]  = fYaxis.GetBinCenter(biny);
         for (Int_t binx = 1; binx <= nbinsx; ++binx) {
            Int_t bin = GetBin(binx,biny,binz);
            x[0]  = fXaxis.GetBinCenter(binx);
            if (range && !f1->IsInside(x)) continue;
            Double_t fu = f1->Eval(x[0], x[1], x[2]);
            if (stat) fu = gRandom->PoissonD(fu);
            AddBinContent(bin, fu);
            if (fSumw2.fN) fSumw2.fArray[bin] += TMath::Abs(fu);
         }
      }
   }
}


//______________________________________________________________________________
void TH1::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
   // Execute action corresponding to one event.
   //
   //     This member function is called when a histogram is clicked with the locator
   //
   //     If Left button clicked on the bin top value, then the content of this bin
   //     is modified according to the new position of the mouse when it is released.

   if (fPainter) fPainter->ExecuteEvent(event, px, py);
}


//______________________________________________________________________________
TH1* TH1::FFT(TH1* h_output, Option_t *option)
{
   // This function allows to do discrete Fourier transforms of TH1 and TH2.
   // Available transform types and flags are described below.
   //
   // To extract more information about the transform, use the function
   //  TVirtualFFT::GetCurrentTransform() to get a pointer to the current
   //  transform object.
   //
   // Parameters:
   //  1st - histogram for the output. If a null pointer is passed, a new histogram is created
   //  and returned, otherwise, the provided histogram is used and should be big enough
   //
   //  Options: option parameters consists of 3 parts:
   //    - option on what to return
   //   "RE" - returns a histogram of the real part of the output
   //   "IM" - returns a histogram of the imaginary part of the output
   //   "MAG"- returns a histogram of the magnitude of the output
   //   "PH" - returns a histogram of the phase of the output
   //
   //    - option of transform type
   //   "R2C"  - real to complex transforms - default
   //   "R2HC" - real to halfcomplex (special format of storing output data,
   //          results the same as for R2C)
   //   "DHT" - discrete Hartley transform
   //         real to real transforms (sine and cosine):
   //   "R2R_0", "R2R_1", "R2R_2", "R2R_3" - discrete cosine transforms of types I-IV
   //   "R2R_4", "R2R_5", "R2R_6", "R2R_7" - discrete sine transforms of types I-IV
   //    To specify the type of each dimension of a 2-dimensional real to real
   //    transform, use options of form "R2R_XX", for example, "R2R_02" for a transform,
   //    which is of type "R2R_0" in 1st dimension and  "R2R_2" in the 2nd.
   //
   //    - option of transform flag
   //    "ES" (from "estimate") - no time in preparing the transform, but probably sub-optimal
   //       performance
   //    "M" (from "measure")   - some time spend in finding the optimal way to do the transform
   //    "P" (from "patient")   - more time spend in finding the optimal way to do the transform
   //    "EX" (from "exhaustive") - the most optimal way is found
   //     This option should be chosen depending on how many transforms of the same size and
   //     type are going to be done. Planning is only done once, for the first transform of this
   //     size and type. Default is "ES".
   //   Examples of valid options: "Mag R2C M" "Re R2R_11" "Im R2C ES" "PH R2HC EX"


   Int_t ndim[3];
   ndim[0] = this->GetNbinsX();
   ndim[1] = this->GetNbinsY();
   ndim[2] = this->GetNbinsZ();

   TVirtualFFT *fft;
   TString opt = option;
   opt.ToUpper();
   if (!opt.Contains("2R")){
      if (!opt.Contains("2C") && !opt.Contains("2HC") && !opt.Contains("DHT")) {
         //no type specified, "R2C" by default
         opt.Append("R2C");
      }
      fft = TVirtualFFT::FFT(this->GetDimension(), ndim, opt.Data());
   }
   else {
      //find the kind of transform
      Int_t ind = opt.Index("R2R", 3);
      Int_t *kind = new Int_t[2];
      char t;
      t = opt[ind+4];
      kind[0] = atoi(&t);
      if (h_output->GetDimension()>1) {
         t = opt[ind+5];
         kind[1] = atoi(&t);
      }
      fft = TVirtualFFT::SineCosine(this->GetDimension(), ndim, kind, option);
      delete [] kind;
   }

   if (!fft) return 0;
   Int_t in=0;
   for (Int_t binx = 1; binx<=ndim[0]; binx++) {
      for (Int_t biny=1; biny<=ndim[1]; biny++) {
         for (Int_t binz=1; binz<=ndim[2]; binz++) {
            fft->SetPoint(in, this->GetBinContent(binx, biny, binz));
            in++;
         }
      }
   }
   fft->Transform();
   h_output = TransformHisto(fft, h_output, option);
   return h_output;
}


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

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

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


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

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

   Int_t bin;
   fEntries++;
   bin =fXaxis.FindBin(x);
   if (bin <0) return -1;
   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 (bin == 0 || bin > fXaxis.GetNbins()) {
      if (!fgStatOverflows) return -1;
   }
   Double_t z= w;
   fTsumw   += z;
   fTsumw2  += z*z;
   fTsumwx  += z*x;
   fTsumwx2 += z*x*x;
   return bin;
}


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

   Int_t bin;
   fEntries++;
   bin =fXaxis.FindBin(namex);
   if (bin <0) return -1;
   if (!fSumw2.fN && w != 1.0 && !TestBit(TH1::kIsNotW))  Sumw2();
   if (fSumw2.fN) fSumw2.fArray[bin] += w*w;
   AddBinContent(bin, w);
   if (bin == 0 || bin > fXaxis.GetNbins()) return -1;
   Double_t z= w;
   fTsumw   += z;
   fTsumw2  += z*z;
   // this make sense if the histogram is not expanding (no axis can be extended)
   if (!CanExtendAllAxes()) {
      Double_t x = fXaxis.GetBinCenter(bin);
      fTsumwx  += z*x;
      fTsumwx2 += z*x*x;
   }
   return bin;
}


//______________________________________________________________________________
void TH1::FillN(Int_t ntimes, const Double_t *x, const Double_t *w, Int_t stride)
{
   // Fill this histogram with an array x and weights w.
   //
   //    ntimes:  number of entries in arrays x and w (array size must be ntimes*stride)
   //    x:       array of values to be histogrammed
   //    w:       array of weighs
   //    stride:  step size through arrays x and w
   //
   //    If the weight is not equal to 1, the storage of the sum of squares of
   //    weights is automatically triggered and the sum of the squares of weights is incremented
   //    by w^2 in the bin corresponding to x.
   //    if w is NULL each entry is assumed a weight=1

   
   //If a buffer is activated, fill buffer
   if (fBuffer) {
      ntimes *= stride;
      Int_t i = 0;
      for (i=0;i<ntimes;i+=stride) {
         if (!fBuffer) break;   // buffer can be deleted in BufferFill when is empty
         if (w) BufferFill(x[i],w[i]);
         else BufferFill(x[i], 1.);
      }
      // fill the remaining entries if the buffer has been deleted 
      if (i < ntimes && fBuffer==0) 
         DoFillN((ntimes-i)/stride,&x[i],&w[i],stride);
      return;
   }
   // call internal method 
   DoFillN(ntimes, x, w, stride);
}

//______________________________________________________________________________
void TH1::DoFillN(Int_t ntimes, const Double_t *x, const Double_t *w, Int_t stride)
{
   // internal method to fill histogram content from a vector
   // called directly by TH1::BufferEmpty

   Int_t bin,i;
   
   fEntries += ntimes;
   Double_t ww = 1;
   Int_t nbins   = fXaxis.GetNbins();
   ntimes *= stride;
   for (i=0;i<ntimes;i+=stride) {
      bin =fXaxis.FindBin(x[i]);
      if (bin <0) continue;
      if (w) ww = w[i];
      if (!fSumw2.fN && ww != 1.0 && !TestBit(TH1::kIsNotW))  Sumw2();
      if (fSumw2.fN) fSumw2.fArray[bin] += ww*ww;
      AddBinContent(bin, ww);
      if (bin == 0 || bin > nbins) {
         if (!fgStatOverflows) continue;
      }
      Double_t z= ww;
      fTsumw   += z;
      fTsumw2  += z*z;
      fTsumwx  += z*x[i];
      fTsumwx2 += z*x[i]*x[i];
   }
}


//______________________________________________________________________________
void TH1::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 for the bin range of this histogram.
   //      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, ibin, loop;
   Double_t r1, x;
   //   - 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

   TAxis * xAxis = &fXaxis;

   // in case axis of histogram is not defined use the function axis
   if (fXaxis.GetXmax() <= fXaxis.GetXmin()) {
      Double_t xmin,xmax;
      f1->GetRange(xmin,xmax);
      Info("FillRandom","Using function axis and range [%g,%g]",xmin, xmax);
      xAxis = f1->GetHistogram()->GetXaxis();
   }

   Int_t first  = xAxis->GetFirst();
   Int_t last   = xAxis->GetLast();
   Int_t nbinsx = last-first+1;

   Double_t *integral = new Double_t[nbinsx+1];
   integral[0] = 0;
   for (binx=1;binx<=nbinsx;binx++) {
      Double_t fint = f1->Integral(xAxis->GetBinLowEdge(binx+first-1),xAxis->GetBinUpEdge(binx+first-1));
      integral[binx] = integral[binx-1] + fint;
   }

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

   //   --------------Start main loop ntimes
   for (loop=0;loop<ntimes;loop++) {
      r1 = gRandom->Rndm(loop);
      ibin = TMath::BinarySearch(nbinsx,&integral[0],r1);
      //binx = 1 + ibin;
      //x    = xAxis->GetBinCenter(binx); //this is not OK when SetBuffer is used
      x    = xAxis->GetBinLowEdge(ibin+first)
             +xAxis->GetBinWidth(ibin+first)*(r1-integral[ibin])/(integral[ibin+1] - integral[ibin]);
      Fill(x);
   }
   delete [] integral;
}


//______________________________________________________________________________
void TH1::FillRandom(TH1 *h, Int_t ntimes)
{
   // Fill histogram following distribution in histogram h.
   //
   //      The distribution contained in the histogram h (TH1) is integrated
   //      over the channel contents for the bin range of this histogram.
   //      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
   //
   //    SPECIAL CASE when the target histogram has the same binning as the source.
   //   in this case we simply use a poisson distribution where
   //   the mean value per bin = bincontent/integral.

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

   //in case the target histogram has the same binning and ntimes much greater
   //than the number of bins we can use a fast method
   Int_t first  = fXaxis.GetFirst();
   Int_t last   = fXaxis.GetLast();
   Int_t nbins = last-first+1;
   if (ntimes > 10*nbins) {
      try {
         CheckConsistency(this,h);
         Double_t sumw = h->Integral(first,last);
         if (sumw == 0) return;
         Double_t sumgen = 0;
         for (Int_t bin=first;bin<=last;bin++) {
            Double_t mean = h->RetrieveBinContent(bin)*ntimes/sumw;
            Double_t cont = (Double_t)gRandom->Poisson(mean);
            sumgen += cont;
            AddBinContent(bin,cont);
            if (fSumw2.fN) fSumw2.fArray[bin] += cont;
         }

         // fix for the fluctations in the total number n
         // since we use Poisson instead of multinomial
         // add a correction to have ntimes as generated entries
         Int_t i;
         if (sumgen < ntimes) {
            // add missing entries
            for (i = Int_t(sumgen+0.5); i < ntimes; ++i)
            {
               Double_t x = h->GetRandom();
               Fill(x);
            }
         }
         else if (sumgen > ntimes) {
            // remove extra entries
            i =  Int_t(sumgen+0.5);
            while( i > ntimes) {
               Double_t x = h->GetRandom();
               Int_t ibin = fXaxis.FindBin(x);
               Double_t y = RetrieveBinContent(ibin);
               // skip in case bin is empty
               if (y > 0) {
                  SetBinContent(ibin, y-1.);
                  i--;
               }
            }
         }

         ResetStats();
         return;
      }
      catch(std::exception&) {}  // do nothing
   }
   // case of different axis and not too large ntimes

   if (h->ComputeIntegral() ==0) return;
   Int_t loop;
   Double_t x;
   for (loop=0;loop<ntimes;loop++) {
      x = h->GetRandom();
      Fill(x);
   }
}


//______________________________________________________________________________
Int_t TH1::FindBin(Double_t x, Double_t y, Double_t z)
{
   //   Return Global bin number corresponding to x,y,z
   //
   //      2-D and 3-D histograms are represented with a one dimensional
   //      structure. This has the advantage that all existing functions, such as
   //      GetBinContent, GetBinError, GetBinFunction work for all dimensions.
   //      This function tries to extend the axis if the given point belongs to an
   //       under-/overflow bin AND if CanExtendAllAxes() is true.
   //     See also TH1::GetBin, TAxis::FindBin and TAxis::FindFixBin

   if (GetDimension() < 2) {
      return fXaxis.FindBin(x);
   }
   if (GetDimension() < 3) {
      Int_t nx   = fXaxis.GetNbins()+2;
      Int_t binx = fXaxis.FindBin(x);
      Int_t biny = fYaxis.FindBin(y);
      return  binx + nx*biny;
   }
   if (GetDimension() < 4) {
      Int_t nx   = fXaxis.GetNbins()+2;
      Int_t ny   = fYaxis.GetNbins()+2;
      Int_t binx = fXaxis.FindBin(x);
      Int_t biny = fYaxis.FindBin(y);
      Int_t binz = fZaxis.FindBin(z);
      return  binx + nx*(biny +ny*binz);
   }
   return -1;
}


//______________________________________________________________________________
Int_t TH1::FindFixBin(Double_t x, Double_t y, Double_t z) const
{
   //   Return Global bin number corresponding to x,y,z.
   //
   //      2-D and 3-D histograms are represented with a one dimensional
   //      structure. This has the advantage that all existing functions, such as
   //      GetBinContent, GetBinError, GetBinFunction work for all dimensions.
   //      This function DOES NOT try to extend the axis if the given point belongs
   //      to an under-/overflow bin.
   //     See also TH1::GetBin, TAxis::FindBin and TAxis::FindFixBin

   if (GetDimension() < 2) {
      return fXaxis.FindFixBin(x);
   }
   if (GetDimension() < 3) {
      Int_t nx   = fXaxis.GetNbins()+2;
      Int_t binx = fXaxis.FindFixBin(x);
      Int_t biny = fYaxis.FindFixBin(y);
      return  binx + nx*biny;
   }
   if (GetDimension() < 4) {
      Int_t nx   = fXaxis.GetNbins()+2;
      Int_t ny   = fYaxis.GetNbins()+2;
      Int_t binx = fXaxis.FindFixBin(x);
      Int_t biny = fYaxis.FindFixBin(y);
      Int_t binz = fZaxis.FindFixBin(z);
      return  binx + nx*(biny +ny*binz);
   }
   return -1;
}


//______________________________________________________________________________
Int_t TH1::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 (fBuffer) ((TH1*)this)->BufferEmpty();
   
   if (axis != 1) {
      Warning("FindFirstBinAbove","Invalid axis number : %d, axis x assumed\n",axis);
      axis = 1;
   }
   Int_t nbins = fXaxis.GetNbins();
   for (Int_t bin=1;bin<=nbins;bin++) {
      if (RetrieveBinContent(bin) > threshold) return bin;
   }
   return -1;
}


//______________________________________________________________________________
Int_t TH1::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 (fBuffer) ((TH1*)this)->BufferEmpty();
   
   if (axis != 1) {
      Warning("FindLastBinAbove","Invalid axis number : %d, axis x assumed\n",axis);
      axis = 1;
   }
   Int_t nbins = fXaxis.GetNbins();
   for (Int_t bin=nbins;bin>=1;bin--) {
      if (RetrieveBinContent(bin) > threshold) return bin;
   }
   return -1;
}


//______________________________________________________________________________
TObject *TH1::FindObject(const char *name) const
{
   // search object named name in the list of functions

   if (fFunctions) return fFunctions->FindObject(name);
   return 0;
}


//______________________________________________________________________________
TObject *TH1::FindObject(const TObject *obj) const
{
   // search object obj in the list of functions

   if (fFunctions) return fFunctions->FindObject(obj);
   return 0;
}


//______________________________________________________________________________
TFitResultPtr TH1::Fit(const char *fname ,Option_t *option ,Option_t *goption, Double_t xxmin, Double_t xxmax)
{
   // Fit histogram with function fname.
   //
   //      fname is the name of an already predefined function created by TF1 or TF2
   //      Predefined functions such as gaus, expo and poln are automatically
   //      created by ROOT.
   //      fname can also be a formula, accepted by the linear fitter (linear parts divided
   //      by "++" sign), for example "x++sin(x)" for fitting "[0]*x+[1]*sin(x)"
   //
   //  This function finds a pointer to the TF1 object with name fname
   //  and calls TH1::Fit(TF1 *f1,...)

   char *linear;
   linear= (char*)strstr(fname, "++");
   TF1 *f1=0;
   TF2 *f2=0;
   TF3 *f3=0;
   Int_t ndim=GetDimension();
   if (linear){
      if (ndim<2){
         f1=new TF1(fname, fname, xxmin, xxmax);
         return Fit(f1,option,goption,xxmin,xxmax);
      }
      else if (ndim<3){
         f2=new TF2(fname, fname);
         return Fit(f2,option,goption,xxmin,xxmax);
      }
      else{
         f3=new TF3(fname, fname);
         return Fit(f3,option,goption,xxmin,xxmax);
      }
   }

   else{
      f1 = (TF1*)gROOT->GetFunction(fname);
      if (!f1) { Printf("Unknown function: %s",fname); return -1; }
      return Fit(f1,option,goption,xxmin,xxmax);
   }
}


//______________________________________________________________________________
TFitResultPtr TH1::Fit(TF1 *f1 ,Option_t *option ,Option_t *goption, Double_t xxmin, Double_t xxmax)
{
   // Fit histogram with function f1.
   //
   //      Fit this histogram with function f1.
   //
   //      The list of fit options is given in parameter option.
   //         option = "W"  Set all weights to 1 for non empty bins; ignore error bars
   //                = "WW" Set all weights to 1 including empty bins; ignore error bars
   //                = "I"  Use integral of function in bin, normalized by the bin volume,
   //                       instead of value at bin center
   //                = "L"  Use Loglikelihood method (default is chisquare method)
   //                = "WL" Use Loglikelihood method and bin contents are not integer,
   //                       i.e. histogram is weighted (must have Sumw2() set)
   //                = "U"  Use a User specified fitting algorithm (via SetFCN)
   //                = "Q"  Quiet mode (minimum printing)
   //                = "V"  Verbose mode (default is between Q and V)
   //                = "E"  Perform better Errors estimation using Minos technique
   //                = "B"  User defined parameter settings are used for predefined functions
   //                       like "gaus", "expo", "poln", "landau".
   //                       Use this option when you want to fix one or more parameters for these functions.
   //                = "M"  More. Improve fit results.
   //                       It uses the IMPROVE command of TMinuit (see TMinuit::mnimpr).
   //                       This algorithm attempts to improve the found local minimum by searching for a
   //                       better one.
   //                = "R"  Use the Range specified in the function range
   //                = "N"  Do not store the graphics function, do not draw
   //                = "0"  Do not plot the result of the fit. By default the fitted function
   //                       is drawn unless the option"N" above is specified.
   //                = "+"  Add this new fitted function to the list of fitted functions
   //                       (by default, any previous function is deleted)
   //                = "C"  In case of linear fitting, don't calculate the chisquare
   //                       (saves time)
   //                = "F"  If fitting a polN, switch to minuit fitter
   //                = "S"  The result of the fit is returned in the TFitResultPtr
   //                       (see below Access to the Fit Result)
   //
   //      When the fit is drawn (by default), the parameter goption may be used
   //      to specify a list of graphics options. See TH1::Draw for a complete
   //      list of these options.
   //
   //      In order to use the Range option, one must first create a function
   //      with the expression to be fitted. For example, if your histogram
   //      has a defined range between -4 and 4 and you want to fit a gaussian
   //      only in the interval 1 to 3, you can do:
   //           TF1 *f1 = new TF1("f1", "gaus", 1, 3);
   //           histo->Fit("f1", "R");
   //
   //      Setting initial conditions
   //      ==========================
   //      Parameters must be initialized before invoking the Fit function.
   //      The setting of the parameter initial values is automatic for the
   //      predefined functions : poln, expo, gaus, landau. One can however disable
   //      this automatic computation by specifying the option "B".
   //      Note that if a predefined function is defined with an argument,
   //      eg, gaus(0), expo(1), you must specify the initial values for
   //      the parameters.
   //      You can specify boundary limits for some or all parameters via
   //           f1->SetParLimits(p_number, parmin, parmax);
   //      if parmin>=parmax, the parameter is fixed
   //      Note that you are not forced to fix the limits for all parameters.
   //      For example, if you fit a function with 6 parameters, you can do:
   //        func->SetParameters(0, 3.1, 1.e-6, -8, 0, 100);
   //        func->SetParLimits(3, -10, -4);
   //        func->FixParameter(4, 0);
   //        func->SetParLimits(5, 1, 1);
   //      With this setup, parameters 0->2 can vary freely
   //      Parameter 3 has boundaries [-10,-4] with initial value -8
   //      Parameter 4 is fixed to 0
   //      Parameter 5 is fixed to 100.
   //      When the lower limit and upper limit are equal, the parameter is fixed.
   //      However to fix a parameter to 0, one must call the FixParameter function.
   //
   //      Note that option "I" gives better results but is slower.
   //
   //
   //     Changing the fitting objective function
   //     =======================================
   //     By default a chi square function is used for fitting. When option "L" (or "LL") is used
   //     a Poisson likelihood function (see note below) is used.
   //     The functions are defined in the header Fit/Chi2Func.h or Fit/PoissonLikelihoodFCN and they
   //     are implemented using the routines FitUtil::EvaluateChi2 or FitUtil::EvaluatePoissonLogL in
   //     the file math/mathcore/src/FitUtil.cxx.
   //     To specify a User defined fitting function, specify option "U" and
   //     call the following functions:
   //       TVirtualFitter::Fitter(myhist)->SetFCN(MyFittingFunction)
   //     where MyFittingFunction is of type:
   //     extern void MyFittingFunction(Int_t &npar, Double_t *gin, Double_t &f, Double_t *u, Int_t flag);
   //
   //     Chi2 Fits
   //     =========
   //     By default a chi2 (least-square) fit is performed on the histogram. The so-called modified least-square method
   //     is used where the residual for each bin is computed using as error the observed value (the bin error)
   //
   //     Chi2 = Sum{ ( y(i) - f (x(i) | p )/ e(i) )^2 }
   //
   //     where y(i) is the bin content for each bin i, x(i) is the bin center and e(i) is the bin error (sqrt(y(i) for
   //     an un-weighted histogram. Bins with zero errors are excluded from the fit. See also later the note on the treatment of empty bins.
   //     When using option "I" the residual is computed not using the function value at the bin center, f (x(i) | p), but the integral
   //     of the function in the bin,   Integral{ f(x|p)dx } divided by the bin volume
   //
   //     Likelihood Fits
   //     ===============
   //     When using option "L" a likelihood fit is used instead of the default chi2 square fit.
   //     The likelihood is built assuming a Poisson probability density function for each bin.
   //     The negative log-likelihood to be minimized is
   //      NLL = Sum{ log Poisson( y(i) |{ f(x(i) | p ) ) }
   //     The exact likelihood used is the Poisson likelihood described in this paper:
   //     S. Baker and R. D. Cousins, “Clarification of the use of chi-square and likelihood functions in fits to histograms,”
   //     Nucl. Instrum. Meth. 221 (1984) 437.
   //     This method can then be used only when the bin content represents counts (i.e. errors are sqrt(N) ).
   //     The likelihood method has the advantage of treating correctly bins with low statistics. In case of high
   //     statistics/bin the distribution of the bin content becomes a normal distribution and the likelihood and chi2 fit
   //     give the same result.
   //     The likelihood method, although a bit slower, it is therefore the recommended method in case of low
   //     bin statistics, where the chi2 method may give incorrect results, in particular when there are
   //     several empty bins (see also below).
   //     In case of a weighted histogram, it is possible to perform a likelihood fit by using the
   //     option "WL". Note a weighted histogram is an histogram which has been filled with weights and it
   //     contains the sum of the weight square ( TH1::Sumw2() has been called). The bin error for a weighted
   //     histogram is the square root of the sum of the weight square.
   //
   //     Treatment of Empty Bins
   //     =======================
   //
   //     Empty bins, which have the content equal to zero AND error equal to zero,
   //     are excluded by default from the chisquare fit, but they are considered in the likelihood fit.
   //     since they affect the likelihood if the function value in these bins is not negligible.
   //     When using option "WW" these bins will be considered in the chi2 fit with an error of 1.
   //     Note that if the histogram is having bins with zero content and non zero-errors they are considered as
   //     any other bins in the fit. Instead bins with zero error and non-zero content are excluded in the chi2 fit.
   //     A likelihood fit should also not be peformed on such an histogram, since we are assuming a wrong pdf for each bin.
   //     In general, one should not fit an histogram with non-empty bins and zero errors, apart if all the bins have zero errors.
   //     In this case one could use the option "w", which gives a weight=1 for each bin (unweighted least-square fit).
   //
   //     Fitting a histogram of dimension N with a function of dimension N-1
   //     ===================================================================
   //     It is possible to fit a TH2 with a TF1 or a TH3 with a TF2.
   //     In this case the option "Integral" is not allowed and each cell has
   //     equal weight.
   //
   //     Associated functions
   //     ====================
   //     One or more object (typically a TF1*) can be added to the list
   //     of functions (fFunctions) associated to each histogram.
   //     When TH1::Fit is invoked, the fitted function is added to this list.
   //     Given an histogram h, one can retrieve an associated function
   //     with:  TF1 *myfunc = h->GetFunction("myfunc");
   //
   //     Access to the fit result
   //     ========================
   //     The function returns a TFitResultPtr which can hold a  pointer to a TFitResult object.
   //     By default the TFitResultPtr contains only the status of the fit which is return by an
   //     automatic conversion of the TFitResultPtr to an integer. One can write in this case directly:
   //     Int_t fitStatus =  h->Fit(myFunc)
   //
   //     If the option "S" is instead used, TFitResultPtr contains the TFitResult and behaves as a smart
   //     pointer to it. For example one can do:
   //     TFitResultPtr r = h->Fit(myFunc,"S");
   //     TMatrixDSym cov = r->GetCovarianceMatrix();  //  to access the covariance matrix
   //     Double_t chi2   = r->Chi2(); // to retrieve the fit chi2
   //     Double_t par0   = r->Parameter(0); // retrieve the value for the parameter 0
   //     Double_t err0   = r->ParError(0); // retrieve the error for the parameter 0
   //     r->Print("V");     // print full information of fit including covariance matrix
   //     r->Write();        // store the result in a file
   //
   //     The fit parameters, error and chi2 (but not covariance matrix) can be retrieved also
   //     from the fitted function.
   //     If the histogram is made persistent, the list of
   //     associated functions is also persistent. Given a pointer (see above)
   //     to an associated function myfunc, one can retrieve the function/fit
   //     parameters with calls such as:
   //       Double_t chi2 = myfunc->GetChisquare();
   //       Double_t par0 = myfunc->GetParameter(0); //value of 1st parameter
   //       Double_t err0 = myfunc->GetParError(0);  //error on first parameter
   //
   //     Access to the fit status
   //     ========================
   //     The status of the fit can be obtained converting the TFitResultPtr to an integer
   //     independently if the fit option "S" is used or not:
   //     TFitResultPtr r = h->Fit(myFunc,opt);
   //     Int_t fitStatus = r;
   //
   //     The fitStatus is 0 if the fit is OK (i.e no error occurred).
   //     The value of the fit status code is negative in case of an error not connected with the
   //     minimization procedure, for example  when a wrong function is used.
   //     Otherwise the return value is the one returned from the minimization procedure.
   //     When TMinuit (default case) or Minuit2 are used as minimizer the status returned is :
   //     fitStatus =  migradResult + 10*minosResult + 100*hesseResult + 1000*improveResult.
   //     TMinuit will return 0 (for migrad, minos, hesse or improve) in case of success and 4 in
   //     case of error (see the documentation of TMinuit::mnexcm). So for example, for an error
   //     only in Minos but not in Migrad a fitStatus of 40 will be returned.
   //     Minuit2 will return also 0 in case of success and different values in migrad minos or
   //     hesse depending on the error. See in this case the documentation of
   //     Minuit2Minimizer::Minimize for the migradResult, Minuit2Minimizer::GetMinosError for the
   //     minosResult and Minuit2Minimizer::Hesse for the hesseResult.
   //     If other minimizers are used see their specific documentation for the status code returned.
   //     For example in the case of Fumili, for the status returned see TFumili::Minimize.
   //
   //     Excluding points
   //     ================
   //     Use TF1::RejectPoint inside your fitting function to exclude points
   //     within a certain range from the fit. Example:
   //     Double_t fline(Double_t *x, Double_t *par)
   //     {
   //         if (x[0] > 2.5 && x[0] < 3.5) {
   //           TF1::RejectPoint();
   //           return 0;
   //        }
   //        return par[0] + par[1]*x[0];
   //     }
   //
   //     void exclude() {
   //        TF1 *f1 = new TF1("f1", "[0] +[1]*x +gaus(2)", 0, 5);
   //        f1->SetParameters(6, -1,5, 3, 0.2);
   //        TH1F *h = new TH1F("h", "background + signal", 100, 0, 5);
   //        h->FillRandom("f1", 2000);
   //        TF1 *fline = new TF1("fline", fline, 0, 5, 2);
   //        fline->SetParameters(2, -1);
   //        h->Fit("fline", "l");
   //     }
   //
   //     Warning when using the option "0"
   //     =================================
   //     When selecting the option "0", the fitted function is added to
   //     the list of functions of the histogram, but it is not drawn.
   //     You can undo what you disabled in the following way:
   //       h.Fit("myFunction", "0"); // fit, store function but do not draw
   //       h.Draw(); function is not drawn
   //       const Int_t kNotDraw = 1<<9;
   //       h.GetFunction("myFunction")->ResetBit(kNotDraw);
   //       h.Draw();  // function is visible again
   //
   //     Access to the Minimizer information during fitting
   //     ==================================================
   //     This function calls, the ROOT::Fit::FitObject function implemented in HFitImpl.cxx
   //     which uses the ROOT::Fit::Fitter class. The Fitter class creates the objective fuction
   //     (e.g. chi2 or likelihood) and uses an implementation of the  Minimizer interface for minimizing
   //     the function.
   //     The default minimizer is Minuit (class TMinuitMinimizer which calls TMinuit).
   //     The default  can be set in the resource file in etc/system.rootrc. For example
   //     Root.Fitter:      Minuit2
   //     A different fitter can also be set via ROOT::Math::MinimizerOptions::SetDefaultMinimizer
   //     (or TVirtualFitter::SetDefaultFitter).
   //     For example ROOT::Math::MinimizerOptions::SetDefaultMinimizer("GSLMultiMin","BFGS");
   //     will set the usdage of the BFGS algorithm of the GSL multi-dimensional minimization
   //     (implemented in libMathMore). ROOT::Math::MinimizerOptions can be used also to set other
   //     default options, like maximum number of function calls, minimization tolerance or print
   //     level. See the documentation of this class.
   //
   //     For fitting linear functions (containing the "++" sign" and polN functions,
   //     the linear fitter is automatically initialized.

   // implementation of Fit method is in file hist/src/HFitImpl.cxx
   Foption_t fitOption;
   ROOT::Fit::FitOptionsMake(ROOT::Fit::kHistogram,option,fitOption);

   // create range and minimizer options with default values
   ROOT::Fit::DataRange range(xxmin,xxmax);
   ROOT::Math::MinimizerOptions minOption;

   // need to empty the buffer before
   // (t.b.d. do a ML unbinned fit with buffer data)
   if (fBuffer) BufferEmpty();

   return ROOT::Fit::FitObject(this, f1 , fitOption , minOption, goption, range);
}


//______________________________________________________________________________
void TH1::FitPanel()
{
   // Display a panel with all histogram fit options.
   //
   //      See class TFitPanel for example

   if (!gPad)
      gROOT->MakeDefCanvas();

   if (!gPad) {
      Error("FitPanel", "Unable to create a default canvas");
      return;
   }


   // use plugin manager to create instance of TFitEditor
   TPluginHandler *handler = gROOT->GetPluginManager()->FindHandler("TFitEditor");
   if (handler && handler->LoadPlugin() != -1) {
      if (handler->ExecPlugin(2, gPad, this) == 0)
         Error("FitPanel", "Unable to create the FitPanel");
   }
   else
         Error("FitPanel", "Unable to find the FitPanel plug-in");
}


//______________________________________________________________________________
TH1 *TH1::GetAsymmetry(TH1* h2, Double_t c2, Double_t dc2)
{
   // Return an histogram containing the asymmetry of this histogram with h2,
   // where the asymmetry is defined as:
   //
   //  Asymmetry = (h1 - h2)/(h1 + h2)  where h1 = this
   //
   //  works for 1D, 2D, etc. histograms
   //  c2 is an optional argument that gives a relative weight between the two
   //  histograms, and dc2 is the error on this weight.  This is useful, for example,
   //  when forming an asymmetry between two histograms from 2 different data sets that
   //  need to be normalized to each other in some way.  The function calculates
   //  the errors asumming Poisson statistics on h1 and h2 (that is, dh = sqrt(h)).
   //
   //  example:  assuming 'h1' and 'h2' are already filled
   //
   //     h3 = h1->GetAsymmetry(h2)
   //
   //  then 'h3' is created and filled with the asymmetry between 'h1' and 'h2';
   //  h1 and h2 are left intact.
   //
   //  Note that it is the user's responsibility to manage the created histogram.
   //  The name of the returned histogram will be Asymmetry_nameOfh1-nameOfh2
   //
   //  code proposed by Jason Seely (seely@mit.edu) and adapted by R.Brun
   //
   // clone the histograms so top and bottom will have the
   // correct dimensions:
   // Sumw2 just makes sure the errors will be computed properly
   // when we form sums and ratios below.

   TH1 *h1 = this;
   TString name =  TString::Format("Asymmetry_%s-%s",h1->GetName(),h2->GetName() );
   TH1 *asym   = (TH1*)Clone(name);

   // set also the title
   TString title = TString::Format("(%s - %s)/(%s+%s)",h1->GetName(),h2->GetName(),h1->GetName(),h2->GetName() );
   asym->SetTitle(title);

   asym->Sumw2();
   Bool_t addStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory(kFALSE);
   TH1 *top    = (TH1*)asym->Clone();
   TH1 *bottom = (TH1*)asym->Clone();
   TH1::AddDirectory(addStatus);

   // form the top and bottom of the asymmetry, and then divide:
   top->Add(h1,h2,1,-c2);
   bottom->Add(h1,h2,1,c2);
   asym->Divide(top,bottom);

   Int_t   xmax = asym->GetNbinsX();
   Int_t   ymax = asym->GetNbinsY();
   Int_t   zmax = asym->GetNbinsZ();

   if (h1->fBuffer) h1->BufferEmpty(1);
   if (h2->fBuffer) h2->BufferEmpty(1);
   if (bottom->fBuffer) bottom->BufferEmpty(1);

   // now loop over bins to calculate the correct errors
   // the reason this error calculation looks complex is because of c2
   for(Int_t i=1; i<= xmax; i++){
      for(Int_t j=1; j<= ymax; j++){
         for(Int_t k=1; k<= zmax; k++){
            Int_t bin = GetBin(i, j, k);
            // here some bin contents are written into variables to make the error
            // calculation a little more legible:
            Double_t a   = h1->RetrieveBinContent(bin);
            Double_t b   = h2->RetrieveBinContent(bin);
            Double_t bot = bottom->RetrieveBinContent(bin);

            // make sure there are some events, if not, then the errors are set = 0
            // automatically.
            //if(bot < 1){} was changed to the next line from recommendation of Jason Seely (28 Nov 2005)
            if(bot < 1e-6){}
            else{
               // computation of errors by Christos Leonidopoulos
               Double_t dasq  = h1->GetBinErrorSqUnchecked(bin);
               Double_t dbsq  = h2->GetBinErrorSqUnchecked(bin);
               Double_t error = 2*TMath::Sqrt(a*a*c2*c2*dbsq + c2*c2*b*b*dasq+a*a*b*b*dc2*dc2)/(bot*bot);
               asym->SetBinError(i,j,k,error);
            }
         }
      }
   }
   delete top;
   delete bottom;

   return asym;
}


//______________________________________________________________________________
Int_t TH1::GetDefaultBufferSize()
{
   // static function
   // return the default buffer size for automatic histograms
   // the parameter fgBufferSize may be changed via SetDefaultBufferSize

   return fgBufferSize;
}


//______________________________________________________________________________
Bool_t TH1::GetDefaultSumw2()
{
   // static function
   // return kTRUE if TH1::Sumw2 must be called when creating new histograms.
   // see TH1::SetDefaultSumw2.

   return fgDefaultSumw2;
}


//______________________________________________________________________________
Double_t TH1::GetEntries() const
{
   // return the current number of entries

   if (fBuffer) {
      Int_t nentries = (Int_t) fBuffer[0];
      if (nentries > 0) return nentries;
   }

   return fEntries;
}


//______________________________________________________________________________
Double_t TH1::GetEffectiveEntries() const
{
   // number of effective entries of the histogram,
   // neff = (Sum of weights )^2 / (Sum of weight^2 )
   // In case of an unweighted histogram this number is equivalent to the
   // number of entries of the histogram.
   // For a weighted histogram, this number corresponds to the hypotetical number of unweighted entries
   // a histogram would need to have the same statistical power as this weighted histogram.
   // Note: The underflow/overflow are included if one has set the TH1::StatOverFlows flag
   // and if the statistics has been computed at filling time.
   // If a range is set in the histogram the number is computed from the given range.

   Stat_t s[kNstat];
   this->GetStats(s);// s[1] sum of squares of weights, s[0] sum of weights
   return (s[1] ? s[0]*s[0]/s[1] : TMath::Abs(s[0]) );
}


//______________________________________________________________________________
char *TH1::GetObjectInfo(Int_t px, Int_t py) const
{
   //   Redefines TObject::GetObjectInfo.
   //   Displays the histogram info (bin number, contents, integral up to bin
   //   corresponding to cursor position px,py
   //
   return ((TH1*)this)->GetPainter()->GetObjectInfo(px,py);
}


//______________________________________________________________________________
TVirtualHistPainter *TH1::GetPainter(Option_t *option)
{
   // return pointer to painter
   // if painter does not exist, it is created
   if (!fPainter) {
      TString opt = option;
      opt.ToLower();
      if (opt.Contains("gl") || gStyle->GetCanvasPreferGL()) {
         //try to create TGLHistPainter
         TPluginHandler *handler = gROOT->GetPluginManager()->FindHandler("TGLHistPainter");

         if (handler && handler->LoadPlugin() != -1)
            fPainter = reinterpret_cast<TVirtualHistPainter *>(handler->ExecPlugin(1, this));
      }
   }

   if (!fPainter) fPainter = TVirtualHistPainter::HistPainter(this);

   return fPainter;
}


//______________________________________________________________________________
Int_t TH1::GetQuantiles(Int_t nprobSum, Double_t *q, const Double_t *probSum)
{
   // Compute Quantiles for this histogram
   // Quantile x_q of a probability distribution Function F is defined as
   //
   //        F(x_q) = q with 0 <= q <= 1.
   //
   //     For instance the median x_0.5 of a distribution is defined as that value
   //     of the random variable for which the distribution function equals 0.5:
   //
   //        F(x_0.5) = Probability(x < x_0.5) = 0.5
   //
   //  code from Eddy Offermann, Renaissance
   //
   // input parameters
   //   - this 1-d histogram (TH1F,D,etc). Could also be a TProfile
   //   - nprobSum maximum size of array q and size of array probSum (if given)
   //   - probSum array of positions where quantiles will be computed.
   //     if probSum is null, probSum will be computed internally and will
   //     have a size = number of bins + 1 in h. it will correspond to the
   //      quantiles calculated at the lowest edge of the histogram (quantile=0) and
   //     all the upper edges of the bins.
   //     if probSum is not null, it is assumed to contain at least nprobSum values.
   //  output
   //   - return value nq (<=nprobSum) with the number of quantiles computed
   //   - array q filled with nq quantiles
   //
   //  Note that the Integral of the histogram is automatically recomputed
   //  if the number of entries is different of the number of entries when
   //  the integral was computed last time. In case you do not use the Fill
   //  functions to fill your histogram, but SetBinContent, you must call
   //  TH1::ComputeIntegral before calling this function.
   //
   //  Getting quantiles q from two histograms and storing results in a TGraph,
   //   a so-called QQ-plot
   //
   //     TGraph *gr = new TGraph(nprob);
   //     h1->GetQuantiles(nprob,gr->GetX());
   //     h2->GetQuantiles(nprob,gr->GetY());
   //     gr->Draw("alp");
   //
   // Example:
   //     void quantiles() {
   //        // demo for quantiles
   //        const Int_t nq = 20;
   //        TH1F *h = new TH1F("h","demo quantiles",100,-3,3);
   //        h->FillRandom("gaus",5000);
   //
   //        Double_t xq[nq];  // position where to compute the quantiles in [0,1]
   //        Double_t yq[nq];  // array to contain the quantiles
   //        for (Int_t i=0;i<nq;i++) xq[i] = Float_t(i+1)/nq;
   //        h->GetQuantiles(nq,yq,xq);
   //
   //        //show the original histogram in the top pad
   //        TCanvas *c1 = new TCanvas("c1","demo quantiles",10,10,700,900);
   //        c1->Divide(1,2);
   //        c1->cd(1);
   //        h->Draw();
   //
   //        // show the quantiles in the bottom pad
   //        c1->cd(2);
   //        gPad->SetGrid();
   //        TGraph *gr = new TGraph(nq,xq,yq);
   //        gr->SetMarkerStyle(21);
   //        gr->Draw("alp");
   //     }

   if (GetDimension() > 1) {
      Error("GetQuantiles","Only available for 1-d histograms");
      return 0;
   }

   const Int_t nbins = GetXaxis()->GetNbins();
   if (!fIntegral) ComputeIntegral();
   if (fIntegral[nbins+1] != fEntries) ComputeIntegral();

   Int_t i, ibin;
   Double_t *prob = (Double_t*)probSum;
   Int_t nq = nprobSum;
   if (probSum == 0) {
      nq = nbins+1;
      prob = new Double_t[nq];
      prob[0] = 0;
      for (i=1;i<nq;i++) {
         prob[i] = fIntegral[i]/fIntegral[nbins];
      }
   }

   for (i = 0; i < nq; i++) {
      ibin = TMath::BinarySearch(nbins,fIntegral,prob[i]);
      while (ibin < nbins-1 && fIntegral[ibin+1] == prob[i]) {
         if (fIntegral[ibin+2] == prob[i]) ibin++;
         else break;
      }
      q[i] = GetBinLowEdge(ibin+1);
      const Double_t dint = fIntegral[ibin+1]-fIntegral[ibin];
      if (dint > 0) q[i] += GetBinWidth(ibin+1)*(prob[i]-fIntegral[ibin])/dint;
   }

   if (!probSum) delete [] prob;
   return nq;
}


//______________________________________________________________________________
Int_t TH1::FitOptionsMake(Option_t *choptin, Foption_t &fitOption)
{
   // Decode string choptin and fill fitOption structure.

   ROOT::Fit::FitOptionsMake(ROOT::Fit::kHistogram, choptin,fitOption);
   return 1;
}


//______________________________________________________________________________
void H1InitGaus()
{
   // Compute Initial values of parameters for a gaussian.

   Double_t allcha, sumx, sumx2, x, val, rms, mean;
   Int_t bin;
   const Double_t sqrtpi = 2.506628;

   //   - Compute mean value and RMS of the histogram in the given range
   TVirtualFitter *hFitter = TVirtualFitter::GetFitter();
   TH1 *curHist = (TH1*)hFitter->GetObjectFit();
   Int_t hxfirst = hFitter->GetXfirst();
   Int_t hxlast  = hFitter->GetXlast();
   Double_t valmax  = curHist->GetBinContent(hxfirst);
   Double_t binwidx = curHist->GetBinWidth(hxfirst);
   allcha = sumx = sumx2 = 0;
   for (bin=hxfirst;bin<=hxlast;bin++) {
      x       = curHist->GetBinCenter(bin);
      val     = TMath::Abs(curHist->GetBinContent(bin));
      if (val > valmax) valmax = val;
      sumx   += val*x;
      sumx2  += val*x*x;
      allcha += val;
   }
   if (allcha == 0) return;
   mean = sumx/allcha;
   rms  = sumx2/allcha - mean*mean;
   if (rms > 0) rms  = TMath::Sqrt(rms);
   else         rms  = 0;
   if (rms == 0) rms = binwidx*(hxlast-hxfirst+1)/4;
   //if the distribution is really gaussian, the best approximation
   //is binwidx*allcha/(sqrtpi*rms)
   //However, in case of non-gaussian tails, this underestimates
   //the normalisation constant. In this case the maximum value
   //is a better approximation.
   //We take the average of both quantities
   Double_t constant = 0.5*(valmax+binwidx*allcha/(sqrtpi*rms));

   //In case the mean value is outside the histo limits and
   //the RMS is bigger than the range, we take
   //  mean = center of bins
   //  rms  = half range
   Double_t xmin = curHist->GetXaxis()->GetXmin();
   Double_t xmax = curHist->GetXaxis()->GetXmax();
   if ((mean < xmin || mean > xmax) && rms > (xmax-xmin)) {
      mean = 0.5*(xmax+xmin);
      rms  = 0.5*(xmax-xmin);
   }
   TF1 *f1 = (TF1*)hFitter->GetUserFunc();
   f1->SetParameter(0,constant);
   f1->SetParameter(1,mean);
   f1->SetParameter(2,rms);
   f1->SetParLimits(2,0,10*rms);
}


//______________________________________________________________________________
void H1InitExpo()
{
   // Compute Initial values of parameters for an exponential.

   Double_t constant, slope;
   Int_t ifail;
   TVirtualFitter *hFitter = TVirtualFitter::GetFitter();
   Int_t hxfirst = hFitter->GetXfirst();
   Int_t hxlast  = hFitter->GetXlast();
   Int_t nchanx  = hxlast - hxfirst + 1;

   H1LeastSquareLinearFit(-nchanx, constant, slope, ifail);

   TF1 *f1 = (TF1*)hFitter->GetUserFunc();
   f1->SetParameter(0,constant);
   f1->SetParameter(1,slope);

}


//______________________________________________________________________________
void H1InitPolynom()
{
   // Compute Initial values of parameters for a polynom.

   Double_t fitpar[25];

   TVirtualFitter *hFitter = TVirtualFitter::GetFitter();
   TF1 *f1 = (TF1*)hFitter->GetUserFunc();
   Int_t hxfirst = hFitter->GetXfirst();
   Int_t hxlast  = hFitter->GetXlast();
   Int_t nchanx  = hxlast - hxfirst + 1;
   Int_t npar    = f1->GetNpar();

   if (nchanx <=1 || npar == 1) {
      TH1 *curHist = (TH1*)hFitter->GetObjectFit();
      fitpar[0] = curHist->GetSumOfWeights()/Double_t(nchanx);
   } else {
      H1LeastSquareFit( nchanx, npar, fitpar);
   }
   for (Int_t i=0;i<npar;i++) f1->SetParameter(i, fitpar[i]);
}


//______________________________________________________________________________
void H1LeastSquareFit(Int_t n, Int_t m, Double_t *a)
{
   // Least squares lpolynomial fitting without weights.
   //
   //     n   number of points to fit
   //     m   number of parameters
   //     a   array of parameters
   //
   //      based on CERNLIB routine LSQ: Translated to C++ by Rene Brun
   //      (E.Keil.  revised by B.Schorr, 23.10.1981.)

   const Double_t zero = 0.;
   const Double_t one = 1.;
   const Int_t idim = 20;

   Double_t  b[400]        /* was [20][20] */;
   Int_t i, k, l, ifail;
   Double_t power;
   Double_t da[20], xk, yk;

   if (m <= 2) {
      H1LeastSquareLinearFit(n, a[0], a[1], ifail);
      return;
   }
   if (m > idim || m > n) return;
   b[0]  = Double_t(n);
   da[0] = zero;
   for (l = 2; l <= m; ++l) {
      b[l-1]           = zero;
      b[m + l*20 - 21] = zero;
      da[l-1]          = zero;
   }
   TVirtualFitter *hFitter = TVirtualFitter::GetFitter();
   TH1 *curHist  = (TH1*)hFitter->GetObjectFit();
   Int_t hxfirst = hFitter->GetXfirst();
   Int_t hxlast  = hFitter->GetXlast();
   for (k = hxfirst; k <= hxlast; ++k) {
      xk     = curHist->GetBinCenter(k);
      yk     = curHist->GetBinContent(k);
      power  = one;
      da[0] += yk;
      for (l = 2; l <= m; ++l) {
         power   *= xk;
         b[l-1]  += power;
         da[l-1] += power*yk;
      }
      for (l = 2; l <= m; ++l) {
         power            *= xk;
         b[m + l*20 - 21] += power;
      }
   }
   for (i = 3; i <= m; ++i) {
      for (k = i; k <= m; ++k) {
         b[k - 1 + (i-1)*20 - 21] = b[k + (i-2)*20 - 21];
      }
   }
   H1LeastSquareSeqnd(m, b, idim, ifail, 1, da);

   for (i=0; i<m; ++i) a[i] = da[i];

}


//______________________________________________________________________________
void H1LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double_t &a1, Int_t &ifail)
{
   // Least square linear fit without weights.
   //
   //      extracted from CERNLIB LLSQ: Translated to C++ by Rene Brun
   //      (added to LSQ by B. Schorr, 15.02.1982.)

   Double_t xbar, ybar, x2bar;
   Int_t i, n;
   Double_t xybar;
   Double_t fn, xk, yk;
   Double_t det;

   n     = TMath::Abs(ndata);
   ifail = -2;
   xbar  = ybar  = x2bar = xybar = 0;
   TVirtualFitter *hFitter = TVirtualFitter::GetFitter();
   TH1 *curHist  = (TH1*)hFitter->GetObjectFit();
   Int_t hxfirst = hFitter->GetXfirst();
   Int_t hxlast  = hFitter->GetXlast();
   for (i = hxfirst; i <= hxlast; ++i) {
      xk = curHist->GetBinCenter(i);
      yk = curHist->GetBinContent(i);
      if (ndata < 0) {
         if (yk <= 0) yk = 1e-9;
         yk = TMath::Log(yk);
      }
      xbar  += xk;
      ybar  += yk;
      x2bar += xk*xk;
      xybar += xk*yk;
   }
   fn    = Double_t(n);
   det   = fn*x2bar - xbar*xbar;
   ifail = -1;
   if (det <= 0) {
      a0 = ybar/fn;
      a1 = 0;
      return;
   }
   ifail = 0;
   a0 = (x2bar*ybar - xbar*xybar) / det;
   a1 = (fn*xybar - xbar*ybar) / det;

}


//______________________________________________________________________________
void H1LeastSquareSeqnd(Int_t n, Double_t *a, Int_t idim, Int_t &ifail, Int_t k, Double_t *b)
{
   // Extracted from CERN Program library routine DSEQN.
   //
   //           : Translated to C++ by Rene Brun

   Int_t a_dim1, a_offset, b_dim1, b_offset;
   Int_t nmjp1, i, j, l;
   Int_t im1, jp1, nm1, nmi;
   Double_t s1, s21, s22;
   const Double_t one = 1.;

   /* Parameter adjustments */
   b_dim1 = idim;
   b_offset = b_dim1 + 1;
   b -= b_offset;
   a_dim1 = idim;
   a_offset = a_dim1 + 1;
   a -= a_offset;

   if (idim < n) return;

   ifail = 0;
   for (j = 1; j <= n; ++j) {
      if (a[j + j*a_dim1] <= 0) { ifail = -1; return; }
      a[j + j*a_dim1] = one / a[j + j*a_dim1];
      if (j == n) continue;
      jp1 = j + 1;
      for (l = jp1; l <= n; ++l) {
         a[j + l*a_dim1] = a[j + j*a_dim1] * a[l + j*a_dim1];
         s1 = -a[l + (j+1)*a_dim1];
         for (i = 1; i <= j; ++i) { s1 = a[l + i*a_dim1] * a[i + (j+1)*a_dim1] + s1; }
         a[l + (j+1)*a_dim1] = -s1;
      }
   }
   if (k <= 0) return;

   for (l = 1; l <= k; ++l) {
      b[l*b_dim1 + 1] = a[a_dim1 + 1]*b[l*b_dim1 + 1];
   }
   if (n == 1) return;
   for (l = 1; l <= k; ++l) {
      for (i = 2; i <= n; ++i) {
         im1 = i - 1;
         s21 = -b[i + l*b_dim1];
         for (j = 1; j <= im1; ++j) {
            s21 = a[i + j*a_dim1]*b[j + l*b_dim1] + s21;
         }
         b[i + l*b_dim1] = -a[i + i*a_dim1]*s21;
      }
      nm1 = n - 1;
      for (i = 1; i <= nm1; ++i) {
         nmi = n - i;
         s22 = -b[nmi + l*b_dim1];
         for (j = 1; j <= i; ++j) {
            nmjp1 = n - j + 1;
            s22 = a[nmi + nmjp1*a_dim1]*b[nmjp1 + l*b_dim1] + s22;
         }
         b[nmi + l*b_dim1] = -s22;
      }
   }
}


//______________________________________________________________________________
Int_t TH1::GetBin(Int_t binx, Int_t, Int_t) const
{
   // Return Global bin number corresponding to binx,y,z.
   //
   //      2-D and 3-D histograms are represented with a one dimensional
   //      structure.
   //      This has the advantage that all existing functions, such as
   //        GetBinContent, GetBinError, GetBinFunction work for all dimensions.
   //
   //     In case of a TH1x, returns binx directly.
   //     see TH1::GetBinXYZ for the inverse transformation.
   //
   //      Convention for numbering bins
   //      =============================
   //      For all histogram types: nbins, xlow, xup
   //        bin = 0;       underflow bin
   //        bin = 1;       first bin with low-edge xlow INCLUDED
   //        bin = nbins;   last bin with upper-edge xup EXCLUDED
   //        bin = nbins+1; overflow bin
   //      In case of 2-D or 3-D histograms, a "global bin" number is defined.
   //      For example, assuming a 3-D histogram with binx,biny,binz, the function
   //        Int_t bin = h->GetBin(binx,biny,binz);
   //      returns a global/linearized bin number. This global bin is useful
   //      to access the bin information independently of the dimension.

   Int_t ofx = fXaxis.GetNbins() + 1; // overflow bin
   if (binx < 0) binx = 0;
   if (binx > ofx) binx = ofx;

   return binx;
}


//______________________________________________________________________________
void TH1::GetBinXYZ(Int_t binglobal, Int_t &binx, Int_t &biny, Int_t &binz) const
{
   // return binx, biny, binz corresponding to the global bin number globalbin
   // see TH1::GetBin function above

   Int_t nx  = fXaxis.GetNbins()+2;
   Int_t ny  = fYaxis.GetNbins()+2;

   if (GetDimension() < 2) {
      binx = binglobal%nx;
      biny = -1;
      binz = -1;
   }
   if (GetDimension() < 3) {
      binx = binglobal%nx;
      biny = ((binglobal-binx)/nx)%ny;
      binz = -1;
   }
   if (GetDimension() < 4) {
      binx = binglobal%nx;
      biny = ((binglobal-binx)/nx)%ny;
      binz = ((binglobal-binx)/nx -biny)/ny;
   }
}


//______________________________________________________________________________
Double_t TH1::GetRandom() const
{
   // return a random number distributed according the histogram bin contents.
   // This function checks if the bins integral exists. If not, the integral
   // is evaluated, normalized to one.
   // The integral is automatically recomputed if the number of entries
   // is not the same then when the integral was computed.
   // NB Only valid for 1-d histograms. Use GetRandom2 or 3 otherwise.
   // If the histogram has a bin with negative content a NaN is returned

   if (fDimension > 1) {
      Error("GetRandom","Function only valid for 1-d histograms");
      return 0;
   }
   Int_t nbinsx = GetNbinsX();
   Double_t integral = 0;
   // compute integral checking that all bins have positive content (see ROOT-5894)
   if (fIntegral) {
      if (fIntegral[nbinsx+1] != fEntries) integral = ((TH1*)this)->ComputeIntegral(true);
      else  integral = fIntegral[nbinsx];
   } else {
      integral = ((TH1*)this)->ComputeIntegral(true);
   }
   if (integral == 0) return 0;
   // return a NaN in case some bins have negative content
   if (integral == TMath::QuietNaN() ) return TMath::QuietNaN();

   Double_t r1 = gRandom->Rndm();
   Int_t ibin = TMath::BinarySearch(nbinsx,fIntegral,r1);
   Double_t x = GetBinLowEdge(ibin+1);
   if (r1 > fIntegral[ibin]) x +=
      GetBinWidth(ibin+1)*(r1-fIntegral[ibin])/(fIntegral[ibin+1] - fIntegral[ibin]);
   return x;
}


//______________________________________________________________________________
Double_t TH1::GetBinContent(Int_t bin) const
{
   // Return content of bin number bin.
   //
   // Implemented in TH1C,S,F,D
   //
   //      Convention for numbering bins
   //      =============================
   //      For all histogram types: nbins, xlow, xup
   //        bin = 0;       underflow bin
   //        bin = 1;       first bin with low-edge xlow INCLUDED
   //        bin = nbins;   last bin with upper-edge xup EXCLUDED
   //        bin = nbins+1; overflow bin
   //      In case of 2-D or 3-D histograms, a "global bin" number is defined.
   //      For example, assuming a 3-D histogram with binx,biny,binz, the function
   //        Int_t bin = h->GetBin(binx,biny,binz);
   //      returns a global/linearized bin number. This global bin is useful
   //      to access the bin information independently of the dimension.

   if (fBuffer) const_cast<TH1*>(this)->BufferEmpty();
   if (bin < 0) bin = 0;
   if (bin >= fNcells) bin = fNcells-1;

   return RetrieveBinContent(bin);
}


//______________________________________________________________________________
Double_t TH1::GetBinWithContent(Double_t c, Int_t &binx, Int_t firstx, Int_t lastx,Double_t maxdiff) const
{
   // compute first binx in the range [firstx,lastx] for which
   // diff = abs(bin_content-c) <= maxdiff
   // In case several bins in the specified range with diff=0 are found
   // the first bin found is returned in binx.
   // In case several bins in the specified range satisfy diff <=maxdiff
   // the bin with the smallest difference is returned in binx.
   // 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
   //        ie if firstx=0 and lastx=0 (default) the search is on all bins.
   // NOTE2: if maxdiff=0 (default), the first bin with content=c is returned.

   if (fDimension > 1) {
      binx = 0;
      Error("GetBinWithContent","function is only valid for 1-D histograms");
      return 0;
   }

   if (fBuffer) ((TH1*)this)->BufferEmpty();
   
   if (firstx <= 0) firstx = 1;
   if (lastx < firstx) lastx = fXaxis.GetNbins();
   Int_t binminx = 0;
   Double_t diff, curmax = 1.e240;
   for (Int_t i=firstx;i<=lastx;i++) {
      diff = TMath::Abs(RetrieveBinContent(i)-c);
      if (diff <= 0) {binx = i; return diff;}
      if (diff < curmax && diff <= maxdiff) {curmax = diff, binminx=i;}
   }
   binx = binminx;
   return curmax;
}


//______________________________________________________________________________
Double_t TH1::Interpolate(Double_t x)
{
   // Given a point x, approximates the value via linear interpolation
   // based on the two nearest bin centers
   // Andy Mastbaum 10/21/08

   if (fBuffer) ((TH1*)this)->BufferEmpty();
    
   Int_t xbin = FindBin(x);
   Double_t x0,x1,y0,y1;

   if(x<=GetBinCenter(1)) {
      return RetrieveBinContent(1);
   } else if(x>=GetBinCenter(GetNbinsX())) {
      return RetrieveBinContent(GetNbinsX());
   } else {
      if(x<=GetBinCenter(xbin)) {
         y0 = RetrieveBinContent(xbin-1);
         x0 = GetBinCenter(xbin-1);
         y1 = RetrieveBinContent(xbin);
         x1 = GetBinCenter(xbin);
      } else {
         y0 = RetrieveBinContent(xbin);
         x0 = GetBinCenter(xbin);
         y1 = RetrieveBinContent(xbin+1);
         x1 = GetBinCenter(xbin+1);
      }
      return y0 + (x-x0)*((y1-y0)/(x1-x0));
   }
}


//______________________________________________________________________________
Double_t TH1::Interpolate(Double_t, Double_t)
{

   //Not yet implemented
   Error("Interpolate","This function must be called with 1 argument for a TH1");
   return 0;
}


//______________________________________________________________________________
Double_t TH1::Interpolate(Double_t, Double_t, Double_t)
{

   //Not yet implemented
   Error("Interpolate","This function must be called with 1 argument for a TH1");
   return 0;
}


//______________________________________________________________________________
Bool_t TH1::IsBinOverflow(Int_t bin) const
{

   // Return true if the bin is overflow.
   Int_t binx, biny, binz;
   GetBinXYZ(bin, binx, biny, binz);

   if ( fDimension == 1 )
      return binx >= GetNbinsX() + 1;
   else if ( fDimension == 2 )
      return (binx >= GetNbinsX() + 1) ||
             (biny >= GetNbinsY() + 1);
   else if ( fDimension == 3 )
      return (binx >= GetNbinsX() + 1) ||
             (biny >= GetNbinsY() + 1) ||
             (binz >= GetNbinsZ() + 1);
   else
      return 0;
}


//______________________________________________________________________________
Bool_t TH1::IsBinUnderflow(Int_t bin) const
{

   // Return true if the bin is overflow.
   Int_t binx, biny, binz;
   GetBinXYZ(bin, binx, biny, binz);

   if ( fDimension == 1 )
      return (binx <= 0);
   else if ( fDimension == 2 )
      return (binx <= 0 || biny <= 0);
   else if ( fDimension == 3 )
      return (binx <= 0 || biny <= 0 || binz <= 0);
   else
      return 0;
}


//______________________________________________________________________________
void TH1::LabelsDeflate(Option_t *ax)
{
   // Reduce the number of bins for the axis passed in the option to the number of bins having a label.
   // The method will remove only the extra bins existing after the last "labeled" bin.
   // Note that if there are "un-labeled" bins present between "labeled" bins they will not be removed

   Int_t iaxis = AxisChoice(ax);
   TAxis *axis = 0;
   if (iaxis == 1) axis = GetXaxis();
   if (iaxis == 2) axis = GetYaxis();
   if (iaxis == 3) axis = GetZaxis();
   if (!axis) {
      Error("LabelsDeflate","Invalid axis option %s",ax);
      return;
   }
   if (!axis->GetLabels()) return;

   // find bin with last labels
   // bin number is object ID in list of labels
   // therefore max bin number is number of bins of the deflated histograms
   TIter next(axis->GetLabels());
   TObject *obj;
   Int_t nbins = 0;
   while ((obj = next())) {
      Int_t ibin = obj->GetUniqueID();
      if (ibin > nbins) nbins = ibin;
   }
   if (nbins < 1) nbins = 1;
   TH1 *hold = (TH1*)IsA()->New();
   R__ASSERT(hold);
   hold->SetDirectory(0);
   Copy(*hold);

   Bool_t timedisp = axis->GetTimeDisplay();
   Double_t xmin = axis->GetXmin();
   Double_t xmax = axis->GetBinUpEdge(nbins);
   if (xmax <= xmin) xmax = xmin +nbins;
   axis->SetRange(0,0);
   axis->Set(nbins,xmin,xmax);
   SetBinsLength(-1);  // reset the number of cells
   Int_t errors = fSumw2.fN;
   if (errors) fSumw2.Set(fNcells);
   axis->SetTimeDisplay(timedisp);
   // reset histogram content
   Reset("ICE");

   //now loop on all bins and refill
   // NOTE that if the bins without labels have content
   // it will be put in the underflow/overflow.
   // For this reason we use AddBinContent method
   Double_t oldEntries = fEntries;
   Int_t bin,binx,biny,binz;
   for (bin=0; bin < hold->fNcells; ++bin) {
      hold->GetBinXYZ(bin,binx,biny,binz);
      Int_t ibin = GetBin(binx,biny,binz);
      Double_t cu = hold->RetrieveBinContent(bin);
      AddBinContent(ibin,cu);
      if (errors) {
         fSumw2.fArray[ibin] += hold->fSumw2.fArray[bin];
      }
   }
   fEntries = oldEntries;
   delete hold;
}


//______________________________________________________________________________
void TH1::LabelsInflate(Option_t *ax)
{
   // Double the number of bins for axis.
   // Refill histogram
   // This function is called by TAxis::FindBin(const char *label)

   Int_t iaxis = AxisChoice(ax);
   TAxis *axis = 0;
   if (iaxis == 1) axis = GetXaxis();
   if (iaxis == 2) axis = GetYaxis();
   if (iaxis == 3) axis = GetZaxis();
   if (!axis) return;

   TH1 *hold = (TH1*)IsA()->New();;
   hold->SetDirectory(0);
   Copy(*hold);

   Bool_t timedisp = axis->GetTimeDisplay();
   Int_t nbins   = axis->GetNbins();
   Double_t xmin = axis->GetXmin();
   Double_t xmax = axis->GetXmax();
   xmax = xmin + 2*(xmax-xmin);
   axis->SetRange(0,0);
   // double the bins and recompute ncells
   axis->Set(2*nbins,xmin,xmax);
   SetBinsLength(-1);
   Int_t errors = fSumw2.fN;
   if (errors) fSumw2.Set(fNcells);
   axis->SetTimeDisplay(timedisp);

   Reset("ICE");  // reset content and error

   //now loop on all bins and refill
   Double_t oldEntries = fEntries;
   Int_t bin,ibin,binx,biny,binz;
   for (ibin =0; ibin < fNcells; ibin++) {
      GetBinXYZ(ibin,binx,biny,binz);
      bin = hold->GetBin(binx,biny,binz);

      // underflow and overflow will be cleaned up because their meaning has been altered
      if (IsBinUnderflow(bin) || IsBinOverflow(bin)) UpdateBinContent(ibin, 0.0);
      else {
         AddBinContent(ibin, hold->RetrieveBinContent(bin));
         if (errors) fSumw2.fArray[ibin] += hold->fSumw2.fArray[bin];
      }
   }
   fEntries = oldEntries;
   delete hold;
}


//______________________________________________________________________________
void TH1::LabelsOption(Option_t *option, Option_t *ax)
{
   //  Set option(s) to draw axis with labels
   //  option = "a" sort by alphabetic order
   //         = ">" sort by decreasing values
   //         = "<" sort by increasing values
   //         = "h" draw labels horizontal
   //         = "v" draw labels vertical
   //         = "u" draw labels up (end of label right adjusted)
   //         = "d" draw labels down (start of label left adjusted)

   Int_t iaxis = AxisChoice(ax);
   TAxis *axis = 0;
   if (iaxis == 1) axis = GetXaxis();
   if (iaxis == 2) axis = GetYaxis();
   if (iaxis == 3) axis = GetZaxis();
   if (!axis) return;
   THashList *labels = axis->GetLabels();
   if (!labels) {
      Warning("LabelsOption","Cannot sort. No labels");
      return;
   }
   TString opt = option;
   opt.ToLower();
   if (opt.Contains("h")) {
      axis->SetBit(TAxis::kLabelsHori);
      axis->ResetBit(TAxis::kLabelsVert);
      axis->ResetBit(TAxis::kLabelsDown);
      axis->ResetBit(TAxis::kLabelsUp);
   }
   if (opt.Contains("v")) {
      axis->SetBit(TAxis::kLabelsVert);
      axis->ResetBit(TAxis::kLabelsHori);
      axis->ResetBit(TAxis::kLabelsDown);
      axis->ResetBit(TAxis::kLabelsUp);
   }
   if (opt.Contains("u")) {
      axis->SetBit(TAxis::kLabelsUp);
      axis->ResetBit(TAxis::kLabelsVert);
      axis->ResetBit(TAxis::kLabelsDown);
      axis->ResetBit(TAxis::kLabelsHori);
   }
   if (opt.Contains("d")) {
      axis->SetBit(TAxis::kLabelsDown);
      axis->ResetBit(TAxis::kLabelsVert);
      axis->ResetBit(TAxis::kLabelsHori);
      axis->ResetBit(TAxis::kLabelsUp);
   }
   Int_t sort = -1;
   if (opt.Contains("a")) sort = 0;
   if (opt.Contains(">")) sort = 1;
   if (opt.Contains("<")) sort = 2;
   if (sort < 0) return;
   if (sort > 0 && GetDimension() > 2) {
      Error("LabelsOption","Sorting by value not implemented for 3-D histograms");
      return;
   }

   Double_t entries = fEntries;
   Int_t n = TMath::Min(axis->GetNbins(), labels->GetSize());
   Int_t *a = new Int_t[n+2];

   Int_t i,j,k;
   Double_t *cont   = 0;
   Double_t *errors = 0;
   THashList *labold = new THashList(labels->GetSize(),1);
   TIter nextold(labels);
   TObject *obj;
   while ((obj=nextold())) {
      labold->Add(obj);
   }
   labels->Clear();
   if (sort > 0) {
      //---sort by values of bins
      if (GetDimension() == 1) {
         cont = new Double_t[n];
         if (fSumw2.fN) errors = new Double_t[n];
         for (i=1;i<=n;i++) {
            cont[i-1] = GetBinContent(i);
            if (errors) errors[i-1] = GetBinError(i);
         }
         if (sort ==1) TMath::Sort(n,cont,a,kTRUE);  //sort by decreasing values
         else          TMath::Sort(n,cont,a,kFALSE); //sort by increasing values
         for (i=1;i<=n;i++) {
            SetBinContent(i,cont[a[i-1]]);
            if (errors) SetBinError(i,errors[a[i-1]]);
         }
         for (i=1;i<=n;i++) {
            obj = labold->At(a[i-1]);
            labels->Add(obj);
            obj->SetUniqueID(i);
         }
      } else if (GetDimension()== 2) {
         Double_t *pcont = new Double_t[n+2];
         for (i=0;i<=n;i++) pcont[i] = 0;
         Int_t nx = fXaxis.GetNbins();
         Int_t ny = fYaxis.GetNbins();
         cont = new Double_t[(nx+2)*(ny+2)];
         if (fSumw2.fN) errors = new Double_t[(nx+2)*(ny+2)];
         for (i=1;i<=nx;i++) {
            for (j=1;j<=ny;j++) {
               cont[i+nx*j] = GetBinContent(i,j);
               if (errors) errors[i+nx*j] = GetBinError(i,j);
               if (axis == GetXaxis()) k = i;
               else                    k = j;
               pcont[k-1] += cont[i+nx*j];
            }
         }
         if (sort ==1) TMath::Sort(n,pcont,a,kTRUE);  //sort by decreasing values
         else          TMath::Sort(n,pcont,a,kFALSE); //sort by increasing values
         for (i=0;i<n;i++) {
            obj = labold->At(a[i]);
            labels->Add(obj);
            obj->SetUniqueID(i+1);
         }
         delete [] pcont;
         if (axis == GetXaxis()) {
            for (i=1;i<=n;i++) {
               for (j=1;j<=ny;j++) {
                  SetBinContent(i,j,cont[a[i-1]+1+nx*j]);
                  if (errors) SetBinError(i,j,errors[a[i-1]+1+nx*j]);
               }
            }
         }
         else {
            // using y axis
            for (i=1;i<=nx;i++) {
               for (j=1;j<=n;j++) {
                  SetBinContent(i,j,cont[i+nx*(a[j-1]+1)]);
                  if (errors) SetBinError(i,j,errors[i+nx*(a[j-1]+1)]);
               }
            }
         }
      } else {
         //to be implemented for 3d
      }
   } else {
      //---alphabetic sort
      const UInt_t kUsed = 1<<18;
      TObject *objk=0;
      a[0] = 0;
      a[n+1] = n+1;
      for (i=1;i<=n;i++) {
         const char *label = "zzzzzzzzzzzz";
         for (j=1;j<=n;j++) {
            obj = labold->At(j-1);
            if (!obj) continue;
            if (obj->TestBit(kUsed)) continue;
            //use strcasecmp for case non-sensitive sort (may be an option)
            if (strcmp(label,obj->GetName()) < 0) continue;
            objk = obj;
            a[i] = j;
            label = obj->GetName();
         }
         if (objk) {
            objk->SetUniqueID(i);
            labels->Add(objk);
            objk->SetBit(kUsed);
         }
      }
      for (i=1;i<=n;i++) {
         obj = labels->At(i-1);
         if (!obj) continue;
         obj->ResetBit(kUsed);
      }

      if (GetDimension() == 1) {
         cont = new Double_t[n+2];
         if (fSumw2.fN) errors = new Double_t[n+2];
         for (i=1;i<=n;i++) {
            cont[i] = GetBinContent(a[i]);
            if (errors) errors[i] = GetBinError(a[i]);
         }
         for (i=1;i<=n;i++) {
            SetBinContent(i,cont[i]);
            if (errors) SetBinError(i,errors[i]);
         }
      } else if (GetDimension()== 2) {
         Int_t nx = fXaxis.GetNbins()+2;
         Int_t ny = fYaxis.GetNbins()+2;
         cont = new Double_t[nx*ny];
         if (fSumw2.fN) errors = new Double_t[nx*ny];
         for (i=0;i<nx;i++) {
            for (j=0;j<ny;j++) {
               cont[i+nx*j] = GetBinContent(i,j);
               if (errors) errors[i+nx*j] = GetBinError(i,j);
            }
         }
         if (axis == GetXaxis()) {
            for (i=1;i<=n;i++) {
               for (j=0;j<ny;j++) {
                  SetBinContent(i,j,cont[a[i]+nx*j]);
                  if (errors) SetBinError(i,j,errors[a[i]+nx*j]);
               }
            }
         } else {
            for (i=0;i<nx;i++) {
               for (j=1;j<=n;j++) {
                  SetBinContent(i,j,cont[i+nx*a[j]]);
                  if (errors) SetBinError(i,j,errors[i+nx*a[j]]);
               }
            }
         }
      } else {
         Int_t nx = fXaxis.GetNbins()+2;
         Int_t ny = fYaxis.GetNbins()+2;
         Int_t nz = fZaxis.GetNbins()+2;
         cont = new Double_t[nx*ny*nz];
         if (fSumw2.fN) errors = new Double_t[nx*ny*nz];
         for (i=0;i<nx;i++) {
            for (j=0;j<ny;j++) {
               for (k=0;k<nz;k++) {
                  cont[i+nx*(j+ny*k)] = GetBinContent(i,j,k);
                  if (errors) errors[i+nx*(j+ny*k)] = GetBinError(i,j,k);
               }
            }
         }
         if (axis == GetXaxis()) {
            // labels on x axis
            for (i=1;i<=n;i++) {
               for (j=0;j<ny;j++) {
                  for (k=0;k<nz;k++) {
                     SetBinContent(i,j,k,cont[a[i]+nx*(j+ny*k)]);
                     if (errors) SetBinError(i,j,k,errors[a[i]+nx*(j+ny*k)]);
                  }
               }
            }
         }
         else if (axis == GetYaxis()) {
            // labels on y axis
            for (i=0;i<nx;i++) {
               for (j=1;j<=n;j++) {
                  for (k=0;k<nz;k++) {
                     SetBinContent(i,j,k,cont[i+nx*(a[j]+ny*k)]);
                     if (errors) SetBinError(i,j,k,errors[i+nx*(a[j]+ny*k)]);
                  }
               }
            }
         }
         else {
            // labels on z axis
            for (i=0;i<nx;i++) {
               for (j=0;j<ny;j++) {
                  for (k=1;k<=n;k++) {
                     SetBinContent(i,j,k,cont[i+nx*(j+ny*a[k])]);
                     if (errors) SetBinError(i,j,k,errors[i+nx*(j+ny*a[k])]);
                  }
               }
            }
         }
      }
   }
   fEntries = entries;
   delete labold;
   if (a)      delete [] a;
   if (cont)   delete [] cont;
   if (errors) delete [] errors;
}


//______________________________________________________________________________
static inline Bool_t AlmostEqual(Double_t a, Double_t b, Double_t epsilon = 0.00000001)
{
   return TMath::Abs(a - b) < epsilon;
}


//______________________________________________________________________________
static inline Bool_t AlmostInteger(Double_t a, Double_t epsilon = 0.00000001)
{
   return AlmostEqual(a - TMath::Floor(a), 0, epsilon) ||
      AlmostEqual(a - TMath::Floor(a), 1, epsilon);
}

static inline bool IsEquidistantBinning(const TAxis& axis)
{
   // check if axis bin are equals
   if (!axis.GetXbins()->fN) return true;  //
   // not able to check if there is only one axis entry
   bool isEquidistant = true;
   const Double_t firstBinWidth = axis.GetBinWidth(1);
   for (int i = 1; i < axis.GetNbins(); ++i) {
      const Double_t binWidth = axis.GetBinWidth(i);
      const bool match = TMath::AreEqualRel(firstBinWidth, binWidth, TMath::Limits<Double_t>::Epsilon());
      isEquidistant &= match;
      if (!match)
         break;
   }
   return isEquidistant;
}


//______________________________________________________________________________
Bool_t TH1::SameLimitsAndNBins(const TAxis& axis1, const TAxis& axis2)
{
   // Same limits and bins.
   return axis1.GetNbins() == axis2.GetNbins()
      && axis1.GetXmin() == axis2.GetXmin()
      && axis1.GetXmax() == axis2.GetXmax();
}

//______________________________________________________________________________
Bool_t TH1::RecomputeAxisLimits(TAxis& destAxis, const TAxis& anAxis)
{
   // Finds new limits for the axis for the Merge function.
   // returns false if the limits are incompatible
   if (SameLimitsAndNBins(destAxis, anAxis))
      return kTRUE;

   if (!IsEquidistantBinning(destAxis) || !IsEquidistantBinning(anAxis))
      return kFALSE;       // not equidistant user binning not supported

   Double_t width1 = destAxis.GetBinWidth(0);
   Double_t width2 = anAxis.GetBinWidth(0);
   if (width1 == 0 || width2 == 0)
      return kFALSE;       // no binning not supported

   Double_t xmin = TMath::Min(destAxis.GetXmin(), anAxis.GetXmin());
   Double_t xmax = TMath::Max(destAxis.GetXmax(), anAxis.GetXmax());
   Double_t width = TMath::Max(width1, width2);

   // check the bin size
   if (!AlmostInteger(width/width1) || !AlmostInteger(width/width2))
      return kFALSE;

   // std::cout << "Find new limit using given axis " << anAxis.GetXmin() << " , " <<  anAxis.GetXmax() << " bin width " << width2 << std::endl;
   // std::cout << "           and destination axis " << destAxis.GetXmin() << " , " <<  destAxis.GetXmax() << " bin width " << width1 << std::endl;


   // check the limits
   Double_t delta;
   delta = (destAxis.GetXmin() - xmin)/width1;
   if (!AlmostInteger(delta))
      xmin -= (TMath::Ceil(delta) - delta)*width1;

   delta = (anAxis.GetXmin() - xmin)/width2;
   if (!AlmostInteger(delta))
      xmin -= (TMath::Ceil(delta) - delta)*width2;


   delta = (destAxis.GetXmin() - xmin)/width1;
   if (!AlmostInteger(delta))
      return kFALSE;


   delta = (xmax - destAxis.GetXmax())/width1;
   if (!AlmostInteger(delta))
      xmax += (TMath::Ceil(delta) - delta)*width1;


   delta = (xmax - anAxis.GetXmax())/width2;
   if (!AlmostInteger(delta))
      xmax += (TMath::Ceil(delta) - delta)*width2;


   delta = (xmax - destAxis.GetXmax())/width1;
   if (!AlmostInteger(delta))
      return kFALSE;
#ifdef DEBUG
   if (!AlmostInteger((xmax - xmin) / width)) {   // unnecessary check
      printf("TH1::RecomputeAxisLimits - Impossible\n");
      return kFALSE;
   }
#endif


   destAxis.Set(TMath::Nint((xmax - xmin)/width), xmin, xmax);

   //std::cout << "New re-computed axis : [ " << xmin << " , " << xmax << " ] width = " << width << " nbins " << destAxis.GetNbins() << std::endl;

   return kTRUE;
}


//______________________________________________________________________________
Long64_t TH1::Merge(TCollection *li)
{
   // Add all histograms in the collection to this histogram.
   // This function computes the min/max for the x axis,
   // compute a new number of bins, if necessary,
   // add bin contents, errors and statistics.
   // If all histograms have bin labels, bins with identical labels
   // will be merged, no matter what their order is.
   // 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 successful, -1 otherwise.
   //
   // IMPORTANT remark. The axis x 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.
   // Example:
   // void atest() {
   //    TH1F *h1 = new TH1F("h1","h1",110,-110,0);
   //    TH1F *h2 = new TH1F("h2","h2",220,0,110);
   //    TH1F *h3 = new TH1F("h3","h3",330,-55,55);
   //    TRandom r;
   //    for (Int_t i=0;i<10000;i++) {
   //       h1->Fill(r.Gaus(-55,10));
   //       h2->Fill(r.Gaus(55,10));
   //       h3->Fill(r.Gaus(0,10));
   //    }
   //
   //    TList *list = new TList;
   //    list->Add(h1);
   //    list->Add(h2);
   //    list->Add(h3);
   //    TH1F *h = (TH1F*)h1->Clone("h");
   //    h->Reset();
   //    h->Merge(list);
   //    h->Draw();
   // }

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

   // is this really needed ?
   TList inlist;
   inlist.AddAll(li);


   TAxis newXAxis;

   Bool_t initialLimitsFound = kFALSE;
   Bool_t allHaveLabels = kTRUE;  // assume all histo have labels and check later
   Bool_t allHaveLimits = kTRUE;
   Bool_t allSameLimits = kTRUE;
   Bool_t foundLabelHist = kFALSE;
   //Bool_t firstHistWithLimits = kTRUE;


   TIter next(&inlist);
   // start looping with this histogram
   TH1 * h = this;

   do  {
      // do not skip anymore empty histograms
      // since are used to set the limits
      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
#ifdef LATER
         if (firstHistWithLimits ) {
            // set axis limits in the case the first histogram did not have limits
            if (h != this && !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());
            }
            firstHistWithLimits = kFALSE;
         }
#endif

         // this is executed the first time an histogram with limits is found
         // to set some initial values on the new axis
         if (!initialLimitsFound) {
            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());
         }
         else {
            // check first if histograms have same bins
            if (!SameLimitsAndNBins(newXAxis, *(h->GetXaxis())) ) {
               allSameLimits = kFALSE;
               // recompute the limits in this case the optimal limits
               // The condition to works is that the histogram have same bin with
               // and one common bin edge
               if (!RecomputeAxisLimits(newXAxis, *(h->GetXaxis()))) {
                  Error("Merge", "Cannot merge histograms - limits are inconsistent:\n "
                        "first: (%d, %f, %f), second: (%d, %f, %f)",
                        newXAxis.GetNbins(), newXAxis.GetXmin(), newXAxis.GetXmax(),
                        h->GetXaxis()->GetNbins(), h->GetXaxis()->GetXmin(),
                        h->GetXaxis()->GetXmax());
                  return -1;
               }
            }
         }
      }
      if (allHaveLabels) {
         THashList* hlabels=h->GetXaxis()->GetLabels();
         Bool_t haveOneLabel = (hlabels != 0);
         // do here to print message only one time
         if (foundLabelHist && allHaveLabels && !haveOneLabel) {
            Warning("Merge","Not all histograms have labels. I will ignore labels,"
            " falling back to bin numbering mode.");
         }

         allHaveLabels &= (haveOneLabel);
         // for the error message
         if (haveOneLabel) foundLabelHist = kTRUE;
         // If histograms have labels but CanExtendAllAxes() is false
         // use merging of bin content
         if (allHaveLabels && !CanExtendAllAxes()) {
            allHaveLabels = kFALSE;
         }
         // it means
         // I could add a check if histogram contains bins without a label
         // and with non-zero bin content
         // Do we want to support this ???
         // only in case the !h->CanExtendAllAxes()
         if (allHaveLabels && !h->CanExtendAllAxes()) {
            // count number of bins with non-null content
            Int_t non_zero_bins = 0;
            Int_t nbins = h->GetXaxis()->GetNbins();
            if (nbins > hlabels->GetEntries() ) {
               for (Int_t i = 1; i <= nbins; i++) {
                  if (h->RetrieveBinContent(i) != 0 || (fSumw2.fN && h->GetBinError(i) != 0) ) {
                     non_zero_bins++;
                  }
               }
               if (non_zero_bins > hlabels->GetEntries() ) {
                  Warning("Merge","Histogram %s contains non-empty bins without labels - falling back to bin numbering mode",h->GetName() );
                  allHaveLabels = kFALSE;
               }
            }
            // else if (h == this) {
            //    // in case of a full labels histogram set
            //    // the kCanRebin bit otherwise labels will be lost
            //    // Info("Merge","Histogram %s has labels but has not the kCanRebin bit set - set the bit on to not loose labels",GetName() );
            //    // allHaveLabels = kFALSE;
            // }
         }
      }
   }    while ( ( h = dynamic_cast<TH1*> ( 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
   // newXAxis 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
   TH1 * 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 = (TH1*)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);
   }

   // set the binning and cell content on the histogram to merge when the histograms do not have the same binning
   // and when one of the histogram does not have limits
   if (initialLimitsFound && (!allSameLimits || !allHaveLimits )) {
     if (newXAxis.GetXbins()->GetSize() != 0) SetBins(newXAxis.GetNbins(), newXAxis.GetXbins()->GetArray());
     else                                     SetBins(newXAxis.GetNbins(), newXAxis.GetXmin(), newXAxis.GetXmax());
   }

   // std::cout << "Merging on histogram " << GetName() << std::endl;
   // std::cout << "Merging flags : allHaveLimits - allHaveLabels - initialLimitsFound - allSameLimits " << std::endl;
   // std::cout << "                 " << allHaveLimits << "\t\t" << allHaveLabels << "\t\t" <<  initialLimitsFound << "\t\t" <<  allSameLimits << std::endl;


   if (!allHaveLimits && !allHaveLabels) {
      // fill this histogram with all the data from buffers of histograms without limits
      while (TH1* hist = (TH1*)next()) {
         // support also case where some histogram have limits and some have the buffer
         if ( (hist->GetXaxis()->GetXmin() >= hist->GetXaxis()->GetXmax() ) && hist->fBuffer  ) {
            // no limits
            Int_t nbentries = (Int_t)hist->fBuffer[0];
            for (Int_t i = 0; i < nbentries; i++)
               Fill(hist->fBuffer[2*i + 2], hist->fBuffer[2*i + 1]);
            // Entries from buffers have to be filled one by one
            // because FillN doesn't resize histograms.
         }
      }

      // all histograms have been processed
      if (!initialLimitsFound ) {
         // here the case where all histograms don't have limits
         // In principle I should not have copied in hclone since
         // when initialLimitsFound = false then allSameLimits should be  true
         if (hclone) {
            inlist.Remove(hclone);
            delete hclone;
         }
         return (Long64_t) GetEntries();
      }

      // In case some of the histograms do not have limits
      // I need to remove the buffer
      if (fBuffer) BufferEmpty(1);

      next.Reset();
   }

   //merge bin contents and errors
   // in case when histogram have limits

   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();
   UInt_t oldExtendBitMask = CanExtendAllAxes();
   // reset, otherwise setting the under/overflow will extend the axis and make a mess
   if (!allHaveLabels) SetCanExtend(kNoAxis);
   while (TH1* hist=(TH1*)next()) {
      // process only if the histogram has limits; otherwise it was processed before
      // in the case of an existing buffer (see if statement just before)

      //std::cout << "merging histogram " << GetName() << " with " << hist->GetName() << std::endl;

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


      // merge for labels or histogram with limits
      if (allHaveLabels || (hist->GetXaxis()->GetXmin() < hist->GetXaxis()->GetXmax()) ) {
         // import statistics
         hist->GetStats(stats);
         for (Int_t i=0;i<kNstat;i++)
            totstats[i] += stats[i];
         nentries += histEntries;

         Int_t nx = hist->GetXaxis()->GetNbins();
         // loop on bins of the histogram and do the merge
         for (Int_t binx = 0; binx <= nx + 1; binx++) {

            Double_t cu = hist->RetrieveBinContent(binx);
            Double_t e1sq = 0.0;
            Int_t ix = -1;
            if (fSumw2.fN) e1sq= hist->GetBinErrorSqUnchecked(binx);
            // do only for bins with non null bin content or non-null errors (if Sumw2)
            if (TMath::Abs(cu) > 0 || (fSumw2.fN && e1sq > 0 ) ) {
               // case  of overflow bins
               // they do not make sense also in the case of labels
               if (!allHaveLabels) {
                  // case of bins without labels
                  if (!allSameLimits)  {
                     if ( binx==0 || binx== nx+1) {
                        Error("Merge", "Cannot merge histograms - the histograms have"
                              " different limits and undeflows/overflows are present."
                              " The initial histogram is now broken!");
                        return -1;
                     }
                     // NOTE: in the case of one of the histogram  as labels - it is treated as
                     // an error and it has been flagged before
                     // since calling FindBin(x) for histo with labels does not make sense
                     // and the result is unpredictable
                     ix = fXaxis.FindBin(hist->GetXaxis()->GetBinCenter(binx));
                  }
                  else {
                     // histogram have same limits - no need to call FindBin
                     ix = binx;
                  }
               } else {
                  // here only in the case of bins with labels
                  const char* label=hist->GetXaxis()->GetBinLabel(binx);
                  // do we need to support case when there are bins with labels and bins without them ??
                  // NO -then return an error
                  if (label == 0 ) {
                     Error("Merge","Histogram %s with labels has NULL label pointer for bin %d",
                           hist->GetName(),binx );
                     return -1;
                  }
                  // special case for underflow/overflows
                  if (label[0] == 0 &&  (binx == 0 || binx ==(nx+1)) ) { 
                        ix = binx;
                  }
                  else { 
                     // if bin does not exists FindBin will add it automatically
                     // by calling LabelsInflate() if the bit is set
                     // otherwise it will return zero and bin will be merged in underflow/overflow
                     // Do we want to keep this case ??
                     ix = fXaxis.FindBin(label);
                     if (ix <= 0) {
                        Warning("Merge", "Histogram %s has labels but CanExtendAllAxes() is false - label %s is lost", GetName(), label);
                        continue;
                     }
                  }
               }
               if (ix >= 0) {
                  // MERGE here the bin contents
                  //std::cout << "merging bin " << binx << " into " << ix << " with bin content " << cu << " bin center x = " << GetBinCenter(ix) << std::endl;
                  if (ix > fNcells )
                     Fatal("Merge","Fatal error merging histogram %s - bin number is %d and array size is %d",GetName(), ix,fNcells);

                  AddBinContent(ix,cu);
                  if (fSumw2.fN) fSumw2.fArray[ix] += e1sq;
               }
            }
         }
      }
   }
   SetCanExtend(oldExtendBitMask); // restore previous extend state


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


//______________________________________________________________________________
Bool_t TH1::Multiply(TF1 *f1, Double_t c1)
{
   // Performs the operation: this = this*c1*f1
   // if errors are defined (see TH1::Sumw2), errors are also recalculated.
   //
   // Only bins inside the function range are recomputed.
   // IMPORTANT NOTE: If you intend to use the errors of this histogram later
   // you should call Sumw2 before making this operation.
   // This is particularly important if you fit the histogram after TH1::Multiply
   //
   // The function return kFALSE if the Multiply operation failed

   if (!f1) {
      Error("Add","Attempt to multiply by a non-existing function");
      return kFALSE;
   }

   // delete buffer if it is there since it will become invalid
   if (fBuffer) BufferEmpty(1);

   Int_t nx = GetNbinsX() + 2; // normal bins + uf / of (cells)
   Int_t ny = GetNbinsY() + 2;
   Int_t nz = GetNbinsZ() + 2;
   if (fDimension < 2) ny = 1;
   if (fDimension < 3) nz = 1;

   // reset min-maximum
   SetMinimum();
   SetMaximum();

   //   - Loop on bins (including underflows/overflows)
   Double_t xx[3];
   Double_t *params = 0;
   f1->InitArgs(xx,params);

   for (Int_t binz = 0; binz < nz; ++binz) {
      xx[2] = fZaxis.GetBinCenter(binz);
      for (Int_t biny = 0; biny < ny; ++biny) {
         xx[1] = fYaxis.GetBinCenter(biny);
         for (Int_t binx = 0; binx < nx; ++binx) {
            xx[0] = fXaxis.GetBinCenter(binx);
            if (!f1->IsInside(xx)) continue;
            TF1::RejectPoint(kFALSE);
            Int_t bin = binx + nx * (biny + ny *binz);
            Double_t cu  = c1*f1->EvalPar(xx);
            if (TF1::RejectedPoint()) continue;
            UpdateBinContent(bin, RetrieveBinContent(bin) * cu);
            if (fSumw2.fN) {
               fSumw2.fArray[bin] = cu * cu * GetBinErrorSqUnchecked(bin);
            }
         }
      }
   }
   ResetStats();
   return kTRUE;
}


//______________________________________________________________________________
Bool_t TH1::Multiply(const TH1 *h1)
{
   // Multiply this histogram by h1.
   //
   //   this = this*h1
   //
   //   If errors of this are available (TH1::Sumw2), errors are recalculated.
   //   Note that if h1 has Sumw2 set, Sumw2 is automatically called for this
   //   if not already set.
   //
   // IMPORTANT NOTE: If you intend to use the errors of this histogram later
   // you should call Sumw2 before making this operation.
   // This is particularly important if you fit the histogram after TH1::Multiply
   //
   // The function return kFALSE if the Multiply operation failed

   if (!h1) {
      Error("Multiply","Attempt to multiply by a non-existing histogram");
      return kFALSE;
   }

   // delete buffer if it is there since it will become invalid
   if (fBuffer) BufferEmpty(1);

   try {
      CheckConsistency(this,h1);
   } catch(DifferentNumberOfBins&) {
      Error("Multiply","Attempt to multiply histograms with different number of bins");
      return kFALSE;
   } catch(DifferentAxisLimits&) {
      Warning("Multiply","Attempt to multiply histograms with different axis limits");
   } catch(DifferentBinLimits&) {
      Warning("Multiply","Attempt to multiply histograms with different bin limits");
   } catch(DifferentLabels&) {
      Warning("Multiply","Attempt to multiply histograms with different labels");
   }

   //    Create Sumw2 if h1 has Sumw2 set
   if (fSumw2.fN == 0 && h1->GetSumw2N() != 0) Sumw2();

   //   - Reset min-  maximum
   SetMinimum();
   SetMaximum();

   //   - Loop on bins (including underflows/overflows)
   for (Int_t i = 0; i < fNcells; ++i) {
      Double_t c0 = RetrieveBinContent(i);
      Double_t c1 = h1->RetrieveBinContent(i);
      UpdateBinContent(i, c0 * c1);
      if (fSumw2.fN) {
         fSumw2.fArray[i] = GetBinErrorSqUnchecked(i) * c1 * c1 + h1->GetBinErrorSqUnchecked(i) * c0 * c0;
      }
   }
   ResetStats();
   return kTRUE;
}


//______________________________________________________________________________
Bool_t TH1::Multiply(const TH1 *h1, const TH1 *h2, Double_t c1, Double_t c2, Option_t *option)
{
   // Replace contents of this histogram by multiplication of h1 by h2.
   //
   //   this = (c1*h1)*(c2*h2)
   //
   //   If errors of this are available (TH1::Sumw2), errors are recalculated.
   //   Note that if h1 or h2 have Sumw2 set, Sumw2 is automatically called for this
   //   if not already set.
   //
   // IMPORTANT NOTE: If you intend to use the errors of this histogram later
   // you should call Sumw2 before making this operation.
   // This is particularly important if you fit the histogram after TH1::Multiply
   //
   // The function return kFALSE if the Multiply operation failed

   TString opt = option;
   opt.ToLower();
   //   Bool_t binomial = kFALSE;
   //   if (opt.Contains("b")) binomial = kTRUE;
   if (!h1 || !h2) {
      Error("Multiply","Attempt to multiply by a non-existing histogram");
      return kFALSE;
   }

   // delete buffer if it is there since it will become invalid
   if (fBuffer) BufferEmpty(1);

   try {
      CheckConsistency(h1,h2);
      CheckConsistency(this,h1);
   } catch(DifferentNumberOfBins&) {
      Error("Multiply","Attempt to multiply histograms with different number of bins");
      return kFALSE;
   } catch(DifferentAxisLimits&) {
      Warning("Multiply","Attempt to multiply histograms with different axis limits");
   } catch(DifferentBinLimits&) {
      Warning("Multiply","Attempt to multiply histograms with different bin limits");
   } catch(DifferentLabels&) {
      Warning("Multiply","Attempt to multiply histograms with different labels");
   }

   //    Create Sumw2 if h1 or h2 have Sumw2 set
   if (fSumw2.fN == 0 && (h1->GetSumw2N() != 0 || h2->GetSumw2N() != 0)) Sumw2();

   //   - Reset min - maximum
   SetMinimum();
   SetMaximum();

   //   - Loop on bins (including underflows/overflows)
   Double_t c1sq = c1 * c1; Double_t c2sq = c2 * c2;
   for (Int_t i = 0; i < fNcells; ++i) {
      Double_t b1 = h1->RetrieveBinContent(i);
      Double_t b2 = h2->RetrieveBinContent(i);
      UpdateBinContent(i, c1 * b1 * c2 * b2);
      if (fSumw2.fN) {
         fSumw2.fArray[i] = c1sq * c2sq * (h1->GetBinErrorSqUnchecked(i) * b2 * b2 + h2->GetBinErrorSqUnchecked(i) * b1 * b1);
      }
   }
   ResetStats();
   return kTRUE;
}


//______________________________________________________________________________
void TH1::Paint(Option_t *option)
{
   // Control routine to paint any kind of histograms.
   //
   //  This function is automatically called by TCanvas::Update.
   //  (see TH1::Draw for the list of options)

   GetPainter(option);

   if (fPainter) {
      if (strlen(option) > 0) fPainter->Paint(option);
      else                    fPainter->Paint(fOption.Data());
   }
}


//______________________________________________________________________________
TH1 *TH1::Rebin(Int_t ngroup, const char*newname, const Double_t *xbins)
{
   //   Rebin this histogram
   //
   //  -case 1  xbins=0
   //   If newname is blank (default), the current histogram is modified and
   //   a pointer to it is returned.
   //
   //   If newname is not blank, the current histogram is not modified, and a
   //   new histogram is returned which is a Clone of the current histogram
   //   with its name set to newname.
   //
   //   The parameter ngroup indicates how many bins of this have to be merged
   //   into one bin of the result.
   //
   //   If the original histogram has errors stored (via Sumw2), the resulting
   //   histograms has new errors correctly calculated.
   //
   //   examples: if h1 is an existing TH1F histogram with 100 bins
   //     h1->Rebin();  //merges two bins in one in h1: previous contents of h1 are lost
   //     h1->Rebin(5); //merges five bins in one in h1
   //     TH1F *hnew = h1->Rebin(5,"hnew"); // creates a new histogram hnew
   //                                       // merging 5 bins of h1 in one bin
   //
   //   NOTE:  If ngroup is not an exact divider of the number of bins,
   //          the top limit of the rebinned histogram is reduced
   //          to the upper edge of the last bin that can make a complete
   //          group. The remaining bins are added to the overflow bin.
   //          Statistics will be recomputed from the new bin contents.
   //
   //  -case 2  xbins!=0
   //   A new histogram is created (you should specify newname).
   //   The parameter ngroup is the number of variable size bins in the created histogram.
   //   The array xbins must contain ngroup+1 elements that represent the low-edges
   //   of the bins.
   //   If the original histogram has errors stored (via Sumw2), the resulting
   //   histograms has new errors correctly calculated.
   //
   //   NOTE:  The bin edges specified in xbins should correspond to bin edges
   //          in the original histogram. If a bin edge in the new histogram is
   //          in the middle of a bin in the original histogram, all entries in
   //          the split bin in the original histogram will be transfered to the
   //          lower of the two possible bins in the new histogram. This is
   //          probably not what you want.
   //
   //   examples: if h1 is an existing TH1F histogram with 100 bins
   //     Double_t xbins[25] = {...} array of low-edges (xbins[25] is the upper edge of last bin
   //     h1->Rebin(24,"hnew",xbins);  //creates a new variable bin size histogram hnew

   Int_t nbins    = fXaxis.GetNbins();
   Double_t xmin  = fXaxis.GetXmin();
   Double_t xmax  = fXaxis.GetXmax();
   if ((ngroup <= 0) || (ngroup > nbins)) {
      Error("Rebin", "Illegal value of ngroup=%d",ngroup);
      return 0;
   }

   if (fDimension > 1 || InheritsFrom(TProfile::Class())) {
      Error("Rebin", "Operation valid on 1-D histograms only");
      return 0;
   }
   if (!newname && xbins) {
      Error("Rebin","if xbins is specified, newname must be given");
      return 0;
   }

   Int_t newbins = nbins/ngroup;
   if (!xbins) {
      Int_t nbg = nbins/ngroup;
      if (nbg*ngroup != nbins) {
         Warning("Rebin", "ngroup=%d is not an exact divider of nbins=%d.",ngroup,nbins);
      }
   }
   else {
   // in the case that xbins is given (rebinning in variable bins), ngroup is
   // the new number of bins and number of grouped bins is not constant.
   // when looping for setting the contents for the new histogram we
   // need to loop on all bins of original histogram.  Then set ngroup=nbins
      newbins = ngroup;
      ngroup = nbins;
   }

   // Save old bin contents into a new array
   Double_t entries = fEntries;
   Double_t *oldBins = new Double_t[nbins+2];
   Int_t bin, i;
   for (bin=0;bin<nbins+2;bin++) oldBins[bin] = RetrieveBinContent(bin);
   Double_t *oldErrors = 0;
   if (fSumw2.fN != 0) {
      oldErrors = new Double_t[nbins+2];
      for (bin=0;bin<nbins+2;bin++) oldErrors[bin] = GetBinError(bin);
   }
   // rebin will not include underflow/overflow if new axis range is larger than old axis range 
   if (xbins) {  
      if (xbins[0] < fXaxis.GetXmin() && oldBins[0] != 0 )
         Warning("Rebin","underflow entries will not be used when rebinning");
      if (xbins[newbins] > fXaxis.GetXmax() && oldBins[nbins+1] != 0 )
         Warning("Rebin","overflow entries will not be used when rebinning");
   }


   // create a clone of the old histogram if newname is specified
   TH1 *hnew = this;
   if ((newname && strlen(newname) > 0) || xbins) {
      hnew = (TH1*)Clone(newname);
   }

   //reset can extend bit to avoid an axis extension in SetBinContent
   UInt_t oldExtendBitMask = hnew->SetCanExtend(kNoAxis);

   // save original statistics
   Double_t stat[kNstat];
   GetStats(stat);
   bool resetStat = false;
   // change axis specs and rebuild bin contents array::RebinAx
   if(!xbins && (newbins*ngroup != nbins)) {
      xmax = fXaxis.GetBinUpEdge(newbins*ngroup);
      resetStat = true; //stats must be reset because top bins will be moved to overflow bin
   }
   // save the TAttAxis members (reset by SetBins)
   Int_t    nDivisions  = fXaxis.GetNdivisions();
   Color_t  axisColor   = fXaxis.GetAxisColor();
   Color_t  labelColor  = fXaxis.GetLabelColor();
   Style_t  labelFont   = fXaxis.GetLabelFont();
   Float_t  labelOffset = fXaxis.GetLabelOffset();
   Float_t  labelSize   = fXaxis.GetLabelSize();
   Float_t  tickLength  = fXaxis.GetTickLength();
   Float_t  titleOffset = fXaxis.GetTitleOffset();
   Float_t  titleSize   = fXaxis.GetTitleSize();
   Color_t  titleColor  = fXaxis.GetTitleColor();
   Style_t  titleFont   = fXaxis.GetTitleFont();

   if(!xbins && (fXaxis.GetXbins()->GetSize() > 0)){ // variable bin sizes
      Double_t *bins = new Double_t[newbins+1];
      for(i = 0; i <= newbins; ++i) bins[i] = fXaxis.GetBinLowEdge(1+i*ngroup);
      hnew->SetBins(newbins,bins); //this also changes errors array (if any)
      delete [] bins;
   } else if (xbins) {
      hnew->SetBins(newbins,xbins);
   } else {
      hnew->SetBins(newbins,xmin,xmax);
   }

   // Restore axis attributes
   fXaxis.SetNdivisions(nDivisions);
   fXaxis.SetAxisColor(axisColor);
   fXaxis.SetLabelColor(labelColor);
   fXaxis.SetLabelFont(labelFont);
   fXaxis.SetLabelOffset(labelOffset);
   fXaxis.SetLabelSize(labelSize);
   fXaxis.SetTickLength(tickLength);
   fXaxis.SetTitleOffset(titleOffset);
   fXaxis.SetTitleSize(titleSize);
   fXaxis.SetTitleColor(titleColor);
   fXaxis.SetTitleFont(titleFont);

   // copy merged bin contents (ignore under/overflows)
   // Start merging only once the new lowest edge is reached
   Int_t startbin = 1;
   const Double_t newxmin = hnew->GetXaxis()->GetBinLowEdge(1);
   while( fXaxis.GetBinCenter(startbin) < newxmin && startbin <= nbins ) {
      startbin++;
   }
   Int_t oldbin = startbin;
   Double_t binContent, binError;
   for (bin = 1;bin<=newbins;bin++) {
      binContent = 0;
      binError   = 0;
      Int_t imax = ngroup;
      Double_t xbinmax = hnew->GetXaxis()->GetBinUpEdge(bin);
      for (i=0;i<ngroup;i++) {
         if( (oldbin+i > nbins) ||
             ( hnew != this && (fXaxis.GetBinCenter(oldbin+i) > xbinmax)) ) {
            imax = i;
            break;
         }
         binContent += oldBins[oldbin+i];
         if (oldErrors) binError += oldErrors[oldbin+i]*oldErrors[oldbin+i];
      }
      hnew->SetBinContent(bin,binContent);
      if (oldErrors) hnew->SetBinError(bin,TMath::Sqrt(binError));
      oldbin += imax;
   }

   // sum underflow and overflow contents until startbin
   binContent = 0;
   binError = 0;
   for (i = 0; i < startbin; ++i)  {
      binContent += oldBins[i];
      if (oldErrors) binError += oldErrors[i]*oldErrors[i];
   }
   hnew->SetBinContent(0,binContent);
   if (oldErrors) hnew->SetBinError(0,TMath::Sqrt(binError));
   // sum overflow
   binContent = 0;
   binError = 0;
   for (i = oldbin; i <= nbins+1; ++i)  {
      binContent += oldBins[i];
      if (oldErrors) binError += oldErrors[i]*oldErrors[i];
   }
   hnew->SetBinContent(newbins+1,binContent);
   if (oldErrors) hnew->SetBinError(newbins+1,TMath::Sqrt(binError));

   hnew->SetCanExtend(oldExtendBitMask); // restore previous state

   // restore statistics and entries modified by SetBinContent
   hnew->SetEntries(entries);
   if (!resetStat) hnew->PutStats(stat);
   delete [] oldBins;
   if (oldErrors) delete [] oldErrors;
   return hnew;
}


//______________________________________________________________________________
Bool_t TH1::FindNewAxisLimits(const TAxis* axis, const Double_t point, Double_t& newMin, Double_t &newMax)
{
   // finds new limits for the axis so that *point* is within the range and
   // the limits are compatible with the previous ones (see TH1::Merge).
   // new limits are put into *newMin* and *newMax* variables.
   // axis - axis whose limits are to be recomputed
   // point - point that should fit within the new axis limits
   // newMin - new minimum will be stored here
   // newMax - new maximum will be stored here.
   // false if failed (e.g. if the initial axis limits are wrong
   // or the new range is more than 2^64 times the old one).

   Double_t xmin = axis->GetXmin();
   Double_t xmax = axis->GetXmax();
   if (xmin >= xmax) return kFALSE;
   Double_t range = xmax-xmin;
   Double_t binsize = range / axis->GetNbins();

   //recompute new axis limits by doubling the current range
   Int_t ntimes = 0;
   while (point < xmin) {
      if (ntimes++ > 64)
         return kFALSE;
      xmin = xmin - range;
      range *= 2;
      binsize *= 2;
      // // make sure that the merging will be correct
      // if ( xmin / binsize - TMath::Floor(xmin / binsize) >= 0.5) {
      //    xmin += 0.5 * binsize;
      //    xmax += 0.5 * binsize;  // won't work with a histogram with only one bin, but I don't care
      // }
   }
   while (point >= xmax) {
      if (ntimes++ > 64)
         return kFALSE;
      xmax = xmax + range;
      range *= 2;
      binsize *= 2;
      // // make sure that the merging will be correct
      // if ( xmin / binsize - TMath::Floor(xmin / binsize) >= 0.5) {
      //    xmin -= 0.5 * binsize;
      //    xmax -= 0.5 * binsize;  // won't work with a histogram with only one bin, but I don't care
      // }
   }
   newMin = xmin;
   newMax = xmax;
   //   Info("FindNewAxisLimits", "OldAxis: (%lf, %lf), new: (%lf, %lf), point: %lf",
   //      axis->GetXmin(), axis->GetXmax(), xmin, xmax, point);

   return kTRUE;
}


//______________________________________________________________________________
void TH1::ExtendAxis(Double_t x, TAxis *axis)
{
   // Histogram is resized along axis such that x is in the axis range.
   // The new axis limits are recomputed by doubling iteratively
   // the current axis range until the specified value x is within the limits.
   // The algorithm makes a copy of the histogram, then loops on all bins
   // of the old histogram to fill the extended histogram.
   // Takes into account errors (Sumw2) if any.
   // The algorithm works for 1-d, 2-D and 3-D histograms.
   // The axis must be extendable before invoking this function.
   // Ex: h->GetXaxis()->SetCanExtend(kTRUE);

   if (!axis->CanExtend()) return;
   if (TMath::IsNaN(x)) {         // x may be a NaN
      SetCanExtend(kNoAxis);
      return;
   }

   if (axis->GetXmin() >= axis->GetXmax()) return;
   if (axis->GetNbins() <= 0) return;

   Double_t xmin, xmax;
   if (!FindNewAxisLimits(axis, x, xmin, xmax))
      return;

   //save a copy of this histogram
   TH1 *hold = (TH1*)IsA()->New(); 
   hold->SetDirectory(0);
   Copy(*hold);
   //set new axis limits
   axis->SetLimits(xmin,xmax);

   Int_t  nbinsx = fXaxis.GetNbins();
   Int_t  nbinsy = fYaxis.GetNbins();
   Int_t  nbinsz = fZaxis.GetNbins();

   //now loop on all bins and refill
   Double_t bx,by,bz;
   Int_t errors = GetSumw2N();
   Int_t ix,iy,iz,ibin,binx,biny,binz,bin;
   Reset("ICE"); //reset only Integral, contents and Errors
   for (binz=1;binz<=nbinsz;binz++) {
      bz  = hold->GetZaxis()->GetBinCenter(binz);
      iz  = fZaxis.FindFixBin(bz);
      for (biny=1;biny<=nbinsy;biny++) {
         by  = hold->GetYaxis()->GetBinCenter(biny);
         iy  = fYaxis.FindFixBin(by);
         for (binx=1;binx<=nbinsx;binx++) {
            bx = hold->GetXaxis()->GetBinCenter(binx);
            ix  = fXaxis.FindFixBin(bx);
            bin = hold->GetBin(binx,biny,binz);
            ibin= GetBin(ix,iy,iz);
            AddBinContent(ibin, hold->RetrieveBinContent(bin));
            if (errors) {
               fSumw2.fArray[ibin] += hold->GetBinErrorSqUnchecked(bin);
            }
         }
      }
   }
   delete hold;
}


//______________________________________________________________________________
void TH1::RecursiveRemove(TObject *obj)
{
   // Recursively remove object from the list of functions

   if (fFunctions) {
      if (!fFunctions->TestBit(kInvalidObject)) fFunctions->RecursiveRemove(obj);
   }
}


//______________________________________________________________________________
void TH1::Scale(Double_t c1, Option_t *option)
{
   // Multiply this histogram by a constant c1.
   //
   //   this = c1*this
   //
   // Note that both contents and errors(if any) are scaled.
   // This function uses the services of TH1::Add
   //
   // IMPORTANT NOTE: If you intend to use the errors of this histogram later
   // you should call Sumw2 before making this operation.
   // This is particularly important if you fit the histogram after TH1::Scale
   //
   // One can scale an histogram such that the bins integral is equal to
   // the normalization parameter via TH1::Scale(Double_t norm), where norm
   // is the desired normalization divided by the integral of the histogram.
   //
   // If option contains "width" the bin contents and errors are divided
   // by the bin width.


   TString opt = option; opt.ToLower();
   if (opt.Contains("width")) Add(this, this, c1, -1);
   else {
      if (fBuffer) BufferEmpty(1);
      for(Int_t i = 0; i < fNcells; ++i) UpdateBinContent(i, c1 * RetrieveBinContent(i));
      if (fSumw2.fN) for(Int_t i = 0; i < fNcells; ++i) fSumw2.fArray[i] *= (c1 * c1); // update errors
      SetMinimum(); SetMaximum(); // minimum and maximum value will be recalculated the next time
   }

   // if contours set, must also scale contours
   Int_t ncontours = GetContour();
   if (ncontours == 0) return;
   Double_t* levels = fContour.GetArray();
   for (Int_t i = 0; i < ncontours; ++i) levels[i] *= c1;
}


//______________________________________________________________________________
Bool_t TH1::CanExtendAllAxes() const
{
   // returns true if all axes are extendable
   Bool_t canExtend = fXaxis.CanExtend();
   if (GetDimension() > 1) canExtend &= fYaxis.CanExtend();
   if (GetDimension() > 2) canExtend &= fZaxis.CanExtend();

   return canExtend;
}


//______________________________________________________________________________
UInt_t TH1::SetCanExtend(UInt_t extendBitMask)
{
   // make the histogram axes extendable / not extendable according to the bit mask
   // returns the previous bit mask specifying which axes are extendable

   UInt_t oldExtendBitMask = kNoAxis;

   if (fXaxis.CanExtend()) oldExtendBitMask |= kXaxis;
   if (extendBitMask & kXaxis) fXaxis.SetCanExtend(kTRUE);
   else fXaxis.SetCanExtend(kFALSE);

   if (GetDimension() > 1) {
      if (fYaxis.CanExtend()) oldExtendBitMask |= kYaxis;
      if (extendBitMask & kYaxis) fYaxis.SetCanExtend(kTRUE);
      else fYaxis.SetCanExtend(kFALSE);
   }

   if (GetDimension() > 2) {
      if (fZaxis.CanExtend()) oldExtendBitMask |= kZaxis;
      if (extendBitMask & kZaxis) fZaxis.SetCanExtend(kTRUE);
      else fZaxis.SetCanExtend(kFALSE);
   }

   return oldExtendBitMask;
}


//______________________________________________________________________________
void TH1::SetDefaultBufferSize(Int_t buffersize)
{
   // static function to set the default buffer size for automatic histograms.
   // When an histogram is created with one of its axis lower limit greater
   // or equal to its upper limit, the function SetBuffer is automatically
   // called with the default buffer size.

   fgBufferSize = buffersize > 0 ? buffersize : 0;
}


//______________________________________________________________________________
void TH1::SetDefaultSumw2(Bool_t sumw2)
{
   // static function.
   // When this static function is called with sumw2=kTRUE, all new
   // histograms will automatically activate the storage
   // of the sum of squares of errors, ie TH1::Sumw2 is automatically called.

   fgDefaultSumw2 = sumw2;
}


//______________________________________________________________________________
void TH1::SetTitle(const char *title)
{
   // Change (i.e. set) the title
   //
   //   if title is in the form "stringt;stringx;stringy;stringz"
   //   the histogram title is set to stringt, the x axis title to stringx,
   //   the y axis title to stringy, and the z axis title to stringz.
   //   To insert the character ";" in one of the titles, one should use "#;"
   //   or "#semicolon".

   fTitle = title;
   fTitle.ReplaceAll("#;",2,"#semicolon",10);

   // Decode fTitle. It may contain X, Y and Z titles
   TString str1 = fTitle, str2;
   Int_t isc = str1.Index(";");
   Int_t lns = str1.Length();

   if (isc >=0 ) {
      fTitle = str1(0,isc);
      str1   = str1(isc+1, lns);
      isc    = str1.Index(";");
      if (isc >=0 ) {
         str2 = str1(0,isc);
         str2.ReplaceAll("#semicolon",10,";",1);
         fXaxis.SetTitle(str2.Data());
         lns  = str1.Length();
         str1 = str1(isc+1, lns);
         isc  = str1.Index(";");
         if (isc >=0 ) {
            str2 = str1(0,isc);
            str2.ReplaceAll("#semicolon",10,";",1);
            fYaxis.SetTitle(str2.Data());
            lns  = str1.Length();
            str1 = str1(isc+1, lns);
            str1.ReplaceAll("#semicolon",10,";",1);
            fZaxis.SetTitle(str1.Data());
         } else {
            str1.ReplaceAll("#semicolon",10,";",1);
            fYaxis.SetTitle(str1.Data());
         }
      } else {
         str1.ReplaceAll("#semicolon",10,";",1);
         fXaxis.SetTitle(str1.Data());
      }
   }

   fTitle.ReplaceAll("#semicolon",10,";",1);

   if (gPad && TestBit(kMustCleanup)) gPad->Modified();
}


//______________________________________________________________________________
void  TH1::SmoothArray(Int_t nn, Double_t *xx, Int_t ntimes)
{
   // smooth array xx, translation of Hbook routine hsmoof.F
   // based on algorithm 353QH twice presented by J. Friedman
   // in Proc.of the 1974 CERN School of Computing, Norway, 11-24 August, 1974.

   if (nn < 3 ) {
      ::Error("SmoothArray","Need at least 3 points for smoothing: n = %d",nn);
      return;
   }

   Int_t ii;
   Double_t hh[6] = {0,0,0,0,0,0};

   std::vector<double> yy(nn); 
   std::vector<double> zz(nn); 
   std::vector<double> rr(nn); 

   for (Int_t pass=0;pass<ntimes;pass++) {
      // first copy original data into temp array
      std::copy(xx, xx+nn, zz.begin() ); 



      for (int noent = 0; noent < 2; ++noent) { // run algorithm two times 
      
         //  do 353 i.e. running median 3, 5, and 3 in a single loop
         for  (int kk = 0; kk < 3; kk++)  {
            std::copy(zz.begin(), zz.end(), yy.begin());
            int medianType = (kk != 1)  ?  3 : 5; 
            int ifirst      = (kk != 1 ) ?  1 : 2;
            int ilast       = (kk != 1 ) ? nn-1 : nn -2; 
            //nn2 = nn - ik - 1;
            // do all elements beside the first and last point for median 3
            //  and first two and last 2 for median 5
            for  ( ii = ifirst; ii < ilast; ii++)  {
               assert(ii - ifirst >= 0);
               for  (int jj = 0; jj < medianType; jj++)   {
                  hh[jj] = yy[ii - ifirst + jj ];
               }
               zz[ii] = TMath::Median(medianType, hh);
            }

            if  (kk == 0)  {   // first median 3
               // first point
               hh[0] = zz[1];
               hh[1] = zz[0];
               hh[2] = 3*zz[1] - 2*zz[2];
               zz[0] = TMath::Median(3, hh);
               // last point
               hh[0] = zz[nn - 2];
               hh[1] = zz[nn - 1];
               hh[2] = 3*zz[nn - 2] - 2*zz[nn - 3];
               zz[nn - 1] = TMath::Median(3, hh);
            }


            if  (kk == 1)  {   //  median 5
               for  (ii = 0; ii < 3; ii++) {
                  hh[ii] = yy[ii];
               }
               zz[1] = TMath::Median(3, hh);
               // last two points
               for  (ii = 0; ii < 3; ii++) {
                  hh[ii] = yy[nn - 3 + ii];
               }
               zz[nn - 2] = TMath::Median(3, hh);
            }

         }

         std::copy ( zz.begin(), zz.end(), yy.begin() );

         // quadratic interpolation for flat segments
         for (ii = 2; ii < (nn - 2); ii++) {
            if  (zz[ii - 1] != zz[ii]) continue;
            if  (zz[ii] != zz[ii + 1]) continue;
            hh[0] = zz[ii - 2] - zz[ii];
            hh[1] = zz[ii + 2] - zz[ii];
            if  (hh[0] * hh[1] <= 0) continue;
            int jk = 1;
            if  ( TMath::Abs(hh[1]) > TMath::Abs(hh[0]) ) jk = -1;
            yy[ii] = -0.5*zz[ii - 2*jk] + zz[ii]/0.75 + zz[ii + 2*jk] /6.;
            yy[ii + jk] = 0.5*(zz[ii + 2*jk] - zz[ii - 2*jk]) + zz[ii];
         }

         // running means
         //std::copy(zz.begin(), zz.end(), yy.begin()); 
         for  (ii = 1; ii < nn - 1; ii++) {
            zz[ii] = 0.25*yy[ii - 1] + 0.5*yy[ii] + 0.25*yy[ii + 1];
         }
         zz[0] = yy[0];
         zz[nn - 1] = yy[nn - 1];

         if (noent == 0) { 

            // save computed values 
            std::copy(zz.begin(), zz.end(), rr.begin()); 

            // COMPUTE  residuals
            for  (ii = 0; ii < nn; ii++)  {
               zz[ii] = xx[ii] - zz[ii];
            }
         }

      }  // end loop on noent
      
 
      double xmin = TMath::MinElement(nn,xx);
      for  (ii = 0; ii < nn; ii++) {
         if (xmin < 0) xx[ii] = rr[ii] + zz[ii];
         // make smoothing defined positive - not better using 0 ?
         else  xx[ii] = TMath::Max((rr[ii] + zz[ii]),0.0 );
      }
   }
}


//______________________________________________________________________________
void  TH1::Smooth(Int_t ntimes, Option_t *option)
{
   // Smooth bin contents of this histogram.
   // if option contains "R" smoothing is applied only to the bins
   // defined in the X axis range (default is to smooth all bins)
   // Bin contents are replaced by their smooth values.
   // Errors (if any) are not modified.
   // the smoothing procedure is repeated ntimes (default=1)

   if (fDimension != 1) {
      Error("Smooth","Smooth only supported for 1-d histograms");
      return;
   }
   Int_t nbins = fXaxis.GetNbins();
   if (nbins < 3) {
      Error("Smooth","Smooth only supported for histograms with >= 3 bins. Nbins = %d",nbins);
      return;
   }

   // delete buffer if it is there since it will become invalid
   if (fBuffer) BufferEmpty(1);

   Int_t firstbin = 1, lastbin = nbins;
   TString opt = option;
   opt.ToLower();
   if (opt.Contains("r")) {
      firstbin= fXaxis.GetFirst();
      lastbin  = fXaxis.GetLast();
   }
   nbins = lastbin - firstbin + 1;
   Double_t *xx = new Double_t[nbins];
   Double_t nent = fEntries;
   Int_t i;
   for (i=0;i<nbins;i++) {
      xx[i] = RetrieveBinContent(i+firstbin);
   }

   TH1::SmoothArray(nbins,xx,ntimes);

   for (i=0;i<nbins;i++) {
      UpdateBinContent(i+firstbin,xx[i]);
   }
   fEntries = nent;
   delete [] xx;

   if (gPad) gPad->Modified();
}


//______________________________________________________________________________
void  TH1::StatOverflows(Bool_t flag)
{
   //  if flag=kTRUE, underflows and overflows are used by the Fill functions
   //  in the computation of statistics (mean value, RMS).
   //  By default, underflows or overflows are not used.

   fgStatOverflows = flag;
}


//______________________________________________________________________________
void TH1::Streamer(TBuffer &b)
{
   // Stream a class object.

   if (b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = b.ReadVersion(&R__s, &R__c);
      if (fDirectory) fDirectory->Remove(this);
      fDirectory = 0;
      if (R__v > 2) {
         b.ReadClassBuffer(TH1::Class(), this, R__v, R__s, R__c);

         ResetBit(kMustCleanup);
         fXaxis.SetParent(this);
         fYaxis.SetParent(this);
         fZaxis.SetParent(this);
         TIter next(fFunctions);
         TObject *obj;
         while ((obj=next())) {
            if (obj->InheritsFrom(TF1::Class())) ((TF1*)obj)->SetParent(this);
         }
         return;
      }
      //process old versions before automatic schema evolution
      TNamed::Streamer(b);
      TAttLine::Streamer(b);
      TAttFill::Streamer(b);
      TAttMarker::Streamer(b);
      b >> fNcells;
      fXaxis.Streamer(b);
      fYaxis.Streamer(b);
      fZaxis.Streamer(b);
      fXaxis.SetParent(this);
      fYaxis.SetParent(this);
      fZaxis.SetParent(this);
      b >> fBarOffset;
      b >> fBarWidth;
      b >> fEntries;
      b >> fTsumw;
      b >> fTsumw2;
      b >> fTsumwx;
      b >> fTsumwx2;
      if (R__v < 2) {
         Float_t maximum, minimum, norm;
         Float_t *contour=0;
         b >> maximum; fMaximum = maximum;
         b >> minimum; fMinimum = minimum;
         b >> norm;    fNormFactor = norm;
         Int_t n = b.ReadArray(contour);
         fContour.Set(n);
         for (Int_t i=0;i<n;i++) fContour.fArray[i] = contour[i];
         delete [] contour;
      } else {
         b >> fMaximum;
         b >> fMinimum;
         b >> fNormFactor;
         fContour.Streamer(b);
      }
      fSumw2.Streamer(b);
      fOption.Streamer(b);
      fFunctions->Delete();
      fFunctions->Streamer(b);
      b.CheckByteCount(R__s, R__c, TH1::IsA());

   } else {
      b.WriteClassBuffer(TH1::Class(),this);
   }
}


//______________________________________________________________________________
void TH1::Print(Option_t *option) const
{
   // Print some global quantities for this histogram.
   //
   //  If option "base" is given, number of bins and ranges are also printed
   //  If option "range" is given, bin contents and errors are also printed
   //                     for all bins in the current range (default 1-->nbins)
   //  If option "all" is given, bin contents and errors are also printed
   //                     for all bins including under and overflows.

   if (fBuffer) const_cast<TH1*>(this)->BufferEmpty();
   printf( "TH1.Print Name  = %s, Entries= %d, Total sum= %g\n",GetName(),Int_t(fEntries),GetSumOfWeights());
   TString opt = option;
   opt.ToLower();
   Int_t all;
   if      (opt.Contains("all"))   all = 0;
   else if (opt.Contains("range")) all = 1;
   else if (opt.Contains("base"))  all = 2;
   else                            return;

   Int_t bin, binx, biny, binz;
   Int_t firstx=0,lastx=0,firsty=0,lasty=0,firstz=0,lastz=0;
   if (all == 0) {
      lastx  = fXaxis.GetNbins()+1;
      if (fDimension > 1) lasty = fYaxis.GetNbins()+1;
      if (fDimension > 2) lastz = fZaxis.GetNbins()+1;
   } else {
      firstx = fXaxis.GetFirst(); lastx  = fXaxis.GetLast();
      if (fDimension > 1) {firsty = fYaxis.GetFirst(); lasty = fYaxis.GetLast();}
      if (fDimension > 2) {firstz = fZaxis.GetFirst(); lastz = fZaxis.GetLast();}
   }

   if (all== 2) {
      printf("          Title = %s\n", GetTitle());
      printf("          NbinsX= %d, xmin= %g, xmax=%g", fXaxis.GetNbins(), fXaxis.GetXmin(), fXaxis.GetXmax());
      if( fDimension > 1) printf(", NbinsY= %d, ymin= %g, ymax=%g", fYaxis.GetNbins(), fYaxis.GetXmin(), fYaxis.GetXmax());
      if( fDimension > 2) printf(", NbinsZ= %d, zmin= %g, zmax=%g", fZaxis.GetNbins(), fZaxis.GetXmin(), fZaxis.GetXmax());
      printf("\n");
      return;
   }

   Double_t w,e;
   Double_t x,y,z;
   if (fDimension == 1) {
      for (binx=firstx;binx<=lastx;binx++) {
         x = fXaxis.GetBinCenter(binx);
         w = RetrieveBinContent(binx);
         e = GetBinError(binx);
         if(fSumw2.fN) printf(" fSumw[%d]=%g, x=%g, error=%g\n",binx,w,x,e);
         else          printf(" fSumw[%d]=%g, x=%g\n",binx,w,x);
      }
   }
   if (fDimension == 2) {
      for (biny=firsty;biny<=lasty;biny++) {
         y = fYaxis.GetBinCenter(biny);
         for (binx=firstx;binx<=lastx;binx++) {
            bin = GetBin(binx,biny);
            x = fXaxis.GetBinCenter(binx);
            w = RetrieveBinContent(bin);
            e = GetBinError(bin);
            if(fSumw2.fN) printf(" fSumw[%d][%d]=%g, x=%g, y=%g, error=%g\n",binx,biny,w,x,y,e);
            else          printf(" fSumw[%d][%d]=%g, x=%g, y=%g\n",binx,biny,w,x,y);
         }
      }
   }
   if (fDimension == 3) {
      for (binz=firstz;binz<=lastz;binz++) {
         z = fZaxis.GetBinCenter(binz);
         for (biny=firsty;biny<=lasty;biny++) {
            y = fYaxis.GetBinCenter(biny);
            for (binx=firstx;binx<=lastx;binx++) {
               bin = GetBin(binx,biny,binz);
               x = fXaxis.GetBinCenter(binx);
               w = RetrieveBinContent(bin);
               e = GetBinError(bin);
               if(fSumw2.fN) printf(" fSumw[%d][%d][%d]=%g, x=%g, y=%g, z=%g, error=%g\n",binx,biny,binz,w,x,y,z,e);
               else          printf(" fSumw[%d][%d][%d]=%g, x=%g, y=%g, z=%g\n",binx,biny,binz,w,x,y,z);
            }
         }
      }
   }
}


//______________________________________________________________________________
void TH1::Rebuild(Option_t *)
{
   // Using the current bin info, recompute the arrays for contents and errors

   SetBinsLength();
   if (fSumw2.fN) {
      fSumw2.Set(fNcells);
   }
}


//______________________________________________________________________________
void TH1::Reset(Option_t *option)
{
   // Reset this histogram: contents, errors, etc.
   //
   // if option "ICE" is specified, resets only Integral, Contents and Errors.
   // if option "ICES" is specified, resets only Integral, Contents , Errors and Statistics
   //                  This option is used
   // if option "M"   is specified, resets also Minimum and Maximum

   // The option "ICE" is used when extending the histogram (in ExtendAxis, LabelInflate, etc..)
   // The option "ICES is used in combination with the buffer (see BufferEmpty and BufferFill)

   TString opt = option;
   opt.ToUpper();
   fSumw2.Reset();
   if (fIntegral) {delete [] fIntegral; fIntegral = 0;}

   if (opt.Contains("M")) {
      SetMinimum();
      SetMaximum();
   }

   if (opt.Contains("ICE") && !opt.Contains("S")) return;

   // Setting fBuffer[0] = 0 is like resetting the buffer but not deleting it
   // But what is the sense of calling BufferEmpty() ? For making the axes ?
   // BufferEmpty will update contents that later will be
   // reset in calling TH1D::Reset. For this we need to reset the stats afterwards
   // It may be needed for computing the axis limits....
   if (fBuffer) {BufferEmpty(); fBuffer[0] = 0;}

   // need to reset also the statistics
   // (needs to be done after calling BufferEmpty() )
   fTsumw       = 0;
   fTsumw2      = 0;
   fTsumwx      = 0;
   fTsumwx2     = 0;
   fEntries     = 0;

   if (opt == "ICES") return;


   TObject *stats = fFunctions->FindObject("stats");
   fFunctions->Remove(stats);
   //special logic to support the case where the same object is
   //added multiple times in fFunctions.
   //This case happens when the same object is added with different
   //drawing modes
   TObject *obj;
   while ((obj  = fFunctions->First())) {
      while(fFunctions->Remove(obj)) { }
      delete obj;
   }
   if(stats) fFunctions->Add(stats);
   fContour.Set(0);
}


//______________________________________________________________________________
void TH1::SavePrimitive(std::ostream &out, Option_t *option /*= ""*/)
{
   // Save primitive as a C++ statement(s) on output stream out

   // empty the buffer before if it exists
   if (fBuffer) BufferEmpty();

   Bool_t nonEqiX = kFALSE;
   Bool_t nonEqiY = kFALSE;
   Bool_t nonEqiZ = kFALSE;
   Int_t i;
   static Int_t nxaxis = 0;
   static Int_t nyaxis = 0;
   static Int_t nzaxis = 0;
   TString sxaxis="xAxis",syaxis="yAxis",szaxis="zAxis";

   // Check if the histogram has equidistant X bins or not.  If not, we
   // create an array holding the bins.
   if (GetXaxis()->GetXbins()->fN && GetXaxis()->GetXbins()->fArray) {
      nonEqiX = kTRUE;
      nxaxis++;
      sxaxis += nxaxis;
      out << "   Double_t "<<sxaxis<<"[" << GetXaxis()->GetXbins()->fN
         << "] = {";
      for (i = 0; i < GetXaxis()->GetXbins()->fN; i++) {
         if (i != 0) out << ", ";
         out << GetXaxis()->GetXbins()->fArray[i];
      }
      out << "}; " << std::endl;
   }
   // If the histogram is 2 or 3 dimensional, check if the histogram
   // has equidistant Y bins or not.  If not, we create an array
   // holding the bins.
   if (fDimension > 1 && GetYaxis()->GetXbins()->fN &&
      GetYaxis()->GetXbins()->fArray) {
         nonEqiY = kTRUE;
         nyaxis++;
         syaxis += nyaxis;
         out << "   Double_t "<<syaxis<<"[" << GetYaxis()->GetXbins()->fN
            << "] = {";
         for (i = 0; i < GetYaxis()->GetXbins()->fN; i++) {
            if (i != 0) out << ", ";
            out << GetYaxis()->GetXbins()->fArray[i];
         }
         out << "}; " << std::endl;
   }
   // IF the histogram is 3 dimensional, check if the histogram
   // has equidistant Z bins or not.  If not, we create an array
   // holding the bins.
   if (fDimension > 2 && GetZaxis()->GetXbins()->fN &&
      GetZaxis()->GetXbins()->fArray) {
         nonEqiZ = kTRUE;
         nzaxis++;
         szaxis += nzaxis;
         out << "   Double_t "<<szaxis<<"[" << GetZaxis()->GetXbins()->fN
            << "] = {";
         for (i = 0; i < GetZaxis()->GetXbins()->fN; i++) {
            if (i != 0) out << ", ";
            out << GetZaxis()->GetXbins()->fArray[i];
         }
         out << "}; " << std::endl;
   }

   char quote = '"';
   out <<"   "<<std::endl;
   out <<"   "<< ClassName() <<" *";

   // Histogram pointer has by default the histogram name with an incremental suffix.
   // If the histogram belongs to a graph or a stack the suffix is not added because
   // the graph and stack objects are not aware of this new name. Same thing if
   // the histogram is drawn with the option COLZ because the TPaletteAxis drawn
   // when this option is selected, does not know this new name either.
   TString opt = option;
   opt.ToLower();
   static Int_t hcounter = 0;
   TString histName = GetName();
   if (     !histName.Contains("Graph")
         && !histName.Contains("_stack_")
         && !opt.Contains("colz")) {
      histName += ++hcounter;
   }
   const char *hname = histName.Data();
   if (!strlen(hname)) hname = "unnamed";

   TString t(GetTitle());
   t.ReplaceAll("\\","\\\\");
   t.ReplaceAll("\"","\\\"");
   out << hname << " = new " << ClassName() << "(" << quote
      << hname << quote << "," << quote<< t.Data() << quote
      << "," << GetXaxis()->GetNbins();
   if (nonEqiX)
      out << ", "<<sxaxis;
   else
      out << "," << GetXaxis()->GetXmin()
      << "," << GetXaxis()->GetXmax();
   if (fDimension > 1) {
      out << "," << GetYaxis()->GetNbins();
      if (nonEqiY)
         out << ", "<<syaxis;
      else
         out << "," << GetYaxis()->GetXmin()
         << "," << GetYaxis()->GetXmax();
   }
   if (fDimension > 2) {
      out << "," << GetZaxis()->GetNbins();
      if (nonEqiZ)
         out << ", "<<szaxis;
      else
         out << "," << GetZaxis()->GetXmin()
         << "," << GetZaxis()->GetXmax();
   }
   out << ");" << std::endl;

   // save bin contents
   Int_t bin;
   for (bin=0;bin<fNcells;bin++) {
      Double_t bc = RetrieveBinContent(bin);
      if (bc) {
         out<<"   "<<hname<<"->SetBinContent("<<bin<<","<<bc<<");"<<std::endl;
      }
   }

   // save bin errors
   if (fSumw2.fN) {
      for (bin=0;bin<fNcells;bin++) {
         Double_t be = GetBinError(bin);
         if (be) {
            out<<"   "<<hname<<"->SetBinError("<<bin<<","<<be<<");"<<std::endl;
         }
      }
   }

   TH1::SavePrimitiveHelp(out, hname, option);
}


//______________________________________________________________________________
void TH1::SavePrimitiveHelp(std::ostream &out, const char *hname, Option_t *option /*= ""*/)
{
   // helper function for the SavePrimitive functions from TH1
   // or classes derived from TH1, eg TProfile, TProfile2D.

   char quote = '"';
   if (TMath::Abs(GetBarOffset()) > 1e-5) {
      out<<"   "<<hname<<"->SetBarOffset("<<GetBarOffset()<<");"<<std::endl;
   }
   if (TMath::Abs(GetBarWidth()-1) > 1e-5) {
      out<<"   "<<hname<<"->SetBarWidth("<<GetBarWidth()<<");"<<std::endl;
   }
   if (fMinimum != -1111) {
      out<<"   "<<hname<<"->SetMinimum("<<fMinimum<<");"<<std::endl;
   }
   if (fMaximum != -1111) {
      out<<"   "<<hname<<"->SetMaximum("<<fMaximum<<");"<<std::endl;
   }
   if (fNormFactor != 0) {
      out<<"   "<<hname<<"->SetNormFactor("<<fNormFactor<<");"<<std::endl;
   }
   if (fEntries != 0) {
      out<<"   "<<hname<<"->SetEntries("<<fEntries<<");"<<std::endl;
   }
   if (fDirectory == 0) {
      out<<"   "<<hname<<"->SetDirectory(0);"<<std::endl;
   }
   if (TestBit(kNoStats)) {
      out<<"   "<<hname<<"->SetStats(0);"<<std::endl;
   }
   if (fOption.Length() != 0) {
      out<<"   "<<hname<<"->SetOption("<<quote<<fOption.Data()<<quote<<");"<<std::endl;
   }

   // save contour levels
   Int_t ncontours = GetContour();
   if (ncontours > 0) {
      out<<"   "<<hname<<"->SetContour("<<ncontours<<");"<<std::endl;
      Double_t zlevel;
      for (Int_t bin=0;bin<ncontours;bin++) {
         if (gPad->GetLogz()) {
            zlevel = TMath::Power(10,GetContourLevel(bin));
         } else {
            zlevel = GetContourLevel(bin);
         }
         out<<"   "<<hname<<"->SetContourLevel("<<bin<<","<<zlevel<<");"<<std::endl;
      }
   }

   // save list of functions
   TObjOptLink *lnk = (TObjOptLink*)fFunctions->FirstLink();
   TObject *obj;
   static Int_t funcNumber = 0;
   while (lnk) {
      obj = lnk->GetObject();
      obj->SavePrimitive(out,Form("nodraw #%d\n",++funcNumber));
      if (obj->InheritsFrom(TF1::Class())) {
         out<<"   "<<hname<<"->GetListOfFunctions()->Add("
            <<Form("%s%d",obj->GetName(),funcNumber)<<");"<<std::endl;
      } else if (obj->InheritsFrom("TPaveStats")) {
         out<<"   "<<hname<<"->GetListOfFunctions()->Add(ptstats);"<<std::endl;
         out<<"   ptstats->SetParent("<<hname<<");"<<std::endl;
      } else {
         out<<"   "<<hname<<"->GetListOfFunctions()->Add("
            <<obj->GetName()
            <<","<<quote<<lnk->GetOption()<<quote<<");"<<std::endl;
      }
      lnk = (TObjOptLink*)lnk->Next();
   }

   // save attributes
   SaveFillAttributes(out,hname,0,1001);
   SaveLineAttributes(out,hname,1,1,1);
   SaveMarkerAttributes(out,hname,1,1,1);
   fXaxis.SaveAttributes(out,hname,"->GetXaxis()");
   fYaxis.SaveAttributes(out,hname,"->GetYaxis()");
   fZaxis.SaveAttributes(out,hname,"->GetZaxis()");
   TString opt = option;
   opt.ToLower();
   if (!opt.Contains("nodraw")) {
      out<<"   "<<hname<<"->Draw("
         <<quote<<option<<quote<<");"<<std::endl;
   }
}


//______________________________________________________________________________
void TH1::UseCurrentStyle()
{
   //   Copy current attributes from/to current style

   if (!gStyle) return;
   if (gStyle->IsReading()) {
      fXaxis.ResetAttAxis("X");
      fYaxis.ResetAttAxis("Y");
      fZaxis.ResetAttAxis("Z");
      SetBarOffset(gStyle->GetBarOffset());
      SetBarWidth(gStyle->GetBarWidth());
      SetFillColor(gStyle->GetHistFillColor());
      SetFillStyle(gStyle->GetHistFillStyle());
      SetLineColor(gStyle->GetHistLineColor());
      SetLineStyle(gStyle->GetHistLineStyle());
      SetLineWidth(gStyle->GetHistLineWidth());
      SetMarkerColor(gStyle->GetMarkerColor());
      SetMarkerStyle(gStyle->GetMarkerStyle());
      SetMarkerSize(gStyle->GetMarkerSize());
      Int_t dostat = gStyle->GetOptStat();
      if (gStyle->GetOptFit() && !dostat) dostat = 1000000001;
      SetStats(dostat);
   } else {
      gStyle->SetBarOffset(fBarOffset);
      gStyle->SetBarWidth(fBarWidth);
      gStyle->SetHistFillColor(GetFillColor());
      gStyle->SetHistFillStyle(GetFillStyle());
      gStyle->SetHistLineColor(GetLineColor());
      gStyle->SetHistLineStyle(GetLineStyle());
      gStyle->SetHistLineWidth(GetLineWidth());
      gStyle->SetMarkerColor(GetMarkerColor());
      gStyle->SetMarkerStyle(GetMarkerStyle());
      gStyle->SetMarkerSize(GetMarkerSize());
      gStyle->SetOptStat(TestBit(kNoStats));
   }
   TIter next(GetListOfFunctions());
   TObject *obj;

   while ((obj = next())) {
      obj->UseCurrentStyle();
   }
}


//______________________________________________________________________________
Double_t TH1::GetMean(Int_t axis) const
{
   //  For axis = 1,2 or 3 returns the mean value of the histogram along
   //  X,Y or Z axis.
   //  For axis = 11, 12, 13 returns the standard error of the mean value
   //  of the histogram along X, Y or Z axis
   //
   //  Note that the mean value/RMS is computed using the bins in the currently
   //  defined range (see TAxis::SetRange). By default the range includes
   //  all bins from 1 to nbins included, excluding underflows and overflows.
   //  To force the underflows and overflows in the computation, one must
   //  call the static function TH1::StatOverflows(kTRUE) before filling
   //  the histogram.
   //
   // Return mean value of this histogram along the X axis.
   //
   //  Note that the mean value/RMS is computed using the bins in the currently
   //  defined range (see TAxis::SetRange). By default the range includes
   //  all bins from 1 to nbins included, excluding underflows and overflows.
   //  To force the underflows and overflows in the computation, one must
   //  call the static function TH1::StatOverflows(kTRUE) before filling
   //  the histogram.

   if (axis<1 || (axis>3 && axis<11) || axis>13) return 0;
   Double_t stats[kNstat];
   for (Int_t i=4;i<kNstat;i++) stats[i] = 0;
   GetStats(stats);
   if (stats[0] == 0) return 0;
   if (axis<4){
      Int_t ax[3] = {2,4,7};
      return stats[ax[axis-1]]/stats[0];
   } else {
      // mean error = RMS / sqrt( Neff )
      Double_t rms = GetRMS(axis-10);
      Double_t neff = GetEffectiveEntries();
      return ( neff > 0 ? rms/TMath::Sqrt(neff) : 0. );
   }
}


//______________________________________________________________________________
Double_t TH1::GetMeanError(Int_t axis) const
{
   // Return standard error of mean of this histogram along the X axis.
   //
   //  Note that the mean value/RMS is computed using the bins in the currently
   //  defined range (see TAxis::SetRange). By default the range includes
   //  all bins from 1 to nbins included, excluding underflows and overflows.
   //  To force the underflows and overflows in the computation, one must
   //  call the static function TH1::StatOverflows(kTRUE) before filling
   //  the histogram.
   //  Also note, that although the definition of standard error doesn't include the
   //  assumption of normality, many uses of this feature implicitly assume it.

   return GetMean(axis+10);
}


//______________________________________________________________________________
Double_t TH1::GetRMS(Int_t axis) const
{
   //  For axis = 1,2 or 3 returns the Sigma value of the histogram along
   //  X, Y or Z axis
   //  For axis = 11, 12 or 13 returns the error of RMS estimation along
   //  X, Y or Z axis for Normal distribution
   //
   //     Note that the mean value/sigma is computed using the bins in the currently
   //  defined range (see TAxis::SetRange). By default the range includes
   //  all bins from 1 to nbins included, excluding underflows and overflows.
   //  To force the underflows and overflows in the computation, one must
   //  call the static function TH1::StatOverflows(kTRUE) before filling
   //  the histogram.
   //  Note that this function returns the Standard Deviation (Sigma)
   //  of the distribution (not RMS).
   //  The Sigma estimate is computed as Sqrt((1/N)*(Sum(x_i-x_mean)^2))
   //  The name "RMS" was introduced many years ago (Hbook/PAW times).
   //  We kept the name for continuity.

   if (axis<1 || (axis>3 && axis<11) || axis>13) return 0;

   Double_t x, rms2, stats[kNstat];
   for (Int_t i=4;i<kNstat;i++) stats[i] = 0;
   GetStats(stats);
   if (stats[0] == 0) return 0;
   Int_t ax[3] = {2,4,7};
   Int_t axm = ax[axis%10 - 1];
   x    = stats[axm]/stats[0];
   rms2 = TMath::Abs(stats[axm+1]/stats[0] -x*x);
   if (axis<10)
      return TMath::Sqrt(rms2);
   else {
      // The right formula for RMS error depends on 4th momentum (see Kendall-Stuart Vol 1 pag 243)
      // formula valid for only gaussian distribution ( 4-th momentum =  3 * sigma^4 )
      Double_t neff = GetEffectiveEntries();
      return ( neff > 0 ? TMath::Sqrt(rms2/(2*neff) ) : 0. );
   }
}


//______________________________________________________________________________
Double_t TH1::GetRMSError(Int_t axis) const
{
   //  Return error of RMS estimation for Normal distribution
   //
   //  Note that the mean value/RMS is computed using the bins in the currently
   //  defined range (see TAxis::SetRange). By default the range includes
   //  all bins from 1 to nbins included, excluding underflows and overflows.
   //  To force the underflows and overflows in the computation, one must
   //  call the static function TH1::StatOverflows(kTRUE) before filling
   //  the histogram.
   //  Value returned is standard deviation of sample standard deviation.
   //  Note that it is an approximated value which is valid only in the case that the
   //  original data distribution is Normal. The correct one would require
   //  the 4-th momentum value, which cannot be accurately estimated from an histogram since
   //  the x-information for all entries is not kept.

   return GetRMS(axis+10);
}


//______________________________________________________________________________
Double_t TH1::GetSkewness(Int_t axis) const
{
   //For axis = 1, 2 or 3 returns skewness of the histogram along x, y or z axis.
   //For axis = 11, 12 or 13 returns the approximate standard error of skewness
   //of the histogram along x, y or z axis
   //Note, that since third and fourth moment are not calculated
   //at the fill time, skewness and its standard error are computed bin by bin


   if (axis > 0 && axis <= 3){

      Double_t mean = GetMean(axis);
      Double_t rms = GetRMS(axis);
      Double_t rms3 = rms*rms*rms;

      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;
         }
      }

      Double_t x = 0;
      Double_t sum=0;
      Double_t np=0;
      for (Int_t  binx = firstBinX; binx <= lastBinX; binx++) {
         for (Int_t biny = firstBinY; biny <= lastBinY; biny++) {
            for (Int_t binz = firstBinZ; binz <= lastBinZ; binz++) {
               if (axis==1 ) x = fXaxis.GetBinCenter(binx);
               else if (axis==2 ) x = fYaxis.GetBinCenter(biny);
               else if (axis==3 ) x = fZaxis.GetBinCenter(binz);
               Double_t w = GetBinContent(binx,biny,binz);
               np+=w;
               sum+=w*(x-mean)*(x-mean)*(x-mean);
            }
         }
      }
      sum/=np*rms3;
      return sum;
   }
   else if (axis > 10 && axis <= 13) {
      //compute standard error of skewness
      // assume parent normal distribution use formula from  Kendall-Stuart, Vol 1 pag 243, second edition
      Double_t neff = GetEffectiveEntries();
      return ( neff > 0 ? TMath::Sqrt(6./neff ) : 0. );
   }
   else {
      Error("GetSkewness", "illegal value of parameter");
      return 0;
   }
}


//______________________________________________________________________________
Double_t TH1::GetKurtosis(Int_t axis) const
{
   //For axis =1, 2 or 3 returns kurtosis of the histogram along x, y or z axis.
   //Kurtosis(gaussian(0, 1)) = 0.
   //For axis =11, 12 or 13 returns the approximate standard error of kurtosis
   //of the histogram along x, y or z axis
   //Note, that since third and fourth moment are not calculated
   //at the fill time, kurtosis and its standard error are computed bin by bin

   if (axis > 0 && axis <= 3){

      Double_t mean = GetMean(axis);
      Double_t rms = GetRMS(axis);
      Double_t rms4 = rms*rms*rms*rms;

      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;
         }
      }

      Double_t x = 0;
      Double_t sum=0;
      Double_t np=0;
      for (Int_t binx = firstBinX; binx <= lastBinX; binx++) {
         for (Int_t biny = firstBinY; biny <= lastBinY; biny++) {
            for (Int_t binz = firstBinZ; binz <= lastBinZ; binz++) {
               if (axis==1 ) x = fXaxis.GetBinCenter(binx);
               else if (axis==2 ) x = fYaxis.GetBinCenter(biny);
               else if (axis==3 ) x = fZaxis.GetBinCenter(binz);
               Double_t w = GetBinContent(binx,biny,binz);
               np+=w;
               sum+=w*(x-mean)*(x-mean)*(x-mean)*(x-mean);
            }
         }
      }
      sum/=(np*rms4);
      return sum-3;

   } else if (axis > 10 && axis <= 13) {
      //compute standard error of skewness
      // assume parent normal distribution use formula from  Kendall-Stuart, Vol 1 pag 243, second edition
      Double_t neff = GetEffectiveEntries();
      return ( neff > 0 ? TMath::Sqrt(24./neff ) : 0. );
   }
   else {
      Error("GetKurtosis", "illegal value of parameter");
      return 0;
   }
}


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

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

   // Loop on bins (possibly including underflows/overflows)
   Int_t bin, binx;
   Double_t w,err;
   Double_t x;
   // case of labels with extension of axis range
   // statistics in x does not make any sense - set to zero
   if ((const_cast<TAxis&>(fXaxis)).GetLabels() && CanExtendAllAxes() ) {
      stats[0] = fTsumw;
      stats[1] = fTsumw2;
      stats[2] = 0;
      stats[3] = 0;
   }
   else if ((fTsumw == 0 && fEntries > 0) || fXaxis.TestBit(TAxis::kAxisRange)) {
      for (bin=0;bin<4;bin++) stats[bin] = 0;

      Int_t firstBinX = fXaxis.GetFirst();
      Int_t lastBinX  = fXaxis.GetLast();
      // include underflow/overflow if TH1::StatOverflows(kTRUE) in case no range is set on the axis
      if (fgStatOverflows && !fXaxis.TestBit(TAxis::kAxisRange)) {
         if (firstBinX == 1) firstBinX = 0;
         if (lastBinX ==  fXaxis.GetNbins() ) lastBinX += 1;
      }
      for (binx = firstBinX; binx <= lastBinX; binx++) {
         x   = fXaxis.GetBinCenter(binx);
         //w   = TMath::Abs(RetrieveBinContent(binx));
         // not sure what to do here if w < 0
         w   = RetrieveBinContent(binx);
         err = TMath::Abs(GetBinError(binx));
         stats[0] += w;
         stats[1] += err*err;
         stats[2] += w*x;
         stats[3] += w*x*x;
      }
      // if (stats[0] < 0) {
      //    // in case total is negative do something ??
      //    stats[0] = 0;
      // }
   } else {
      stats[0] = fTsumw;
      stats[1] = fTsumw2;
      stats[2] = fTsumwx;
      stats[3] = fTsumwx2;
   }
}


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

   fTsumw   = stats[0];
   fTsumw2  = stats[1];
   fTsumwx  = stats[2];
   fTsumwx2 = stats[3];
}


//______________________________________________________________________________
void TH1::ResetStats()
{
   // Reset the statistics including the number of entries
   // and replace with values calculates from bin content
   // The number of entries is set to the total bin content or (in case of weighted histogram)
   // to number of effective entries
   Double_t stats[kNstat] = {0};
   fTsumw = 0;
   fEntries = 1; // to force re-calculation of the statistics in TH1::GetStats
   GetStats(stats);
   PutStats(stats);
   fEntries = TMath::Abs(fTsumw);
   // use effective entries for weighted histograms:  (sum_w) ^2 / sum_w2
   if (fSumw2.fN > 0 && fTsumw > 0 && stats[1] > 0 ) fEntries = stats[0]*stats[0]/ stats[1];
}


//______________________________________________________________________________
Double_t TH1::GetSumOfWeights() const
{
   // Return the sum of weights excluding under/overflows.

   if (fBuffer) const_cast<TH1*>(this)->BufferEmpty();

   Int_t bin,binx,biny,binz;
   Double_t sum =0;
   for(binz=1; binz<=fZaxis.GetNbins(); binz++) {
      for(biny=1; biny<=fYaxis.GetNbins(); biny++) {
         for(binx=1; binx<=fXaxis.GetNbins(); binx++) {
            bin = GetBin(binx,biny,binz);
            sum += RetrieveBinContent(bin);
         }
      }
   }
   return sum;
}


//______________________________________________________________________________
Double_t TH1::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.

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


//______________________________________________________________________________
Double_t TH1::Integral(Int_t binx1, Int_t binx2, Option_t *option) const
{
   //Return integral of bin contents in range [binx1,binx2]
   // 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.
   double err = 0;
   return DoIntegral(binx1,binx2,0,-1,0,-1,err,option);
}


//______________________________________________________________________________
Double_t TH1::IntegralAndError(Int_t binx1, Int_t binx2, Double_t & error, Option_t *option) const
{
   //Return integral of bin contents in range [binx1,binx2] and its error
   // 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.
   // the error is computed using error propagation from the bin errors assumming that
   // all the bins are uncorrelated
   return DoIntegral(binx1,binx2,0,-1,0,-1,error,option,kTRUE);
}


//______________________________________________________________________________
Double_t TH1::DoIntegral(Int_t binx1, Int_t binx2, Int_t biny1, Int_t biny2, Int_t binz1, Int_t binz2, Double_t & error ,
                          Option_t *option, Bool_t doError) const
{
   // internal function compute integral and optionally the error  between the limits
   // specified by the bin number values working for all histograms (1D, 2D and 3D)

   if (fBuffer) ((TH1*)this)->BufferEmpty();
   
   Int_t nx = GetNbinsX() + 2;
   if (binx1 < 0) binx1 = 0;
   if (binx2 >= nx || binx2 < binx1) binx2 = nx - 1;

   if (GetDimension() > 1) {
      Int_t ny = GetNbinsY() + 2;
      if (biny1 < 0) biny1 = 0;
      if (biny2 >= ny || biny2 < biny1) biny2 = ny - 1;
   } else {
      biny1 = 0; biny2 = 0;
   }

   if (GetDimension() > 2) {
      Int_t nz = GetNbinsZ() + 2;
      if (binz1 < 0) binz1 = 0;
      if (binz2 >= nz || binz2 < binz1) binz2 = nz - 1;
   } else {
      binz1 = 0; binz2 = 0;
   }

   //   - Loop on bins in specified range
   TString opt = option;
   opt.ToLower();
   Bool_t width   = kFALSE;
   if (opt.Contains("width")) width = kTRUE;


   Double_t dx = 1., dy = .1, dz =.1;
   Double_t integral = 0;
   Double_t igerr2 = 0;
   for (Int_t binx = binx1; binx <= binx2; ++binx) {
      if (width) dx = fXaxis.GetBinWidth(binx);
      for (Int_t biny = biny1; biny <= biny2; ++biny) {
         if (width) dy = fYaxis.GetBinWidth(biny);
         for (Int_t binz = binz1; binz <= binz2; ++binz) {
            Int_t bin = GetBin(binx, biny, binz);
            Double_t dv = 0.0;
            if (width) {
               dz = fZaxis.GetBinWidth(binz);
               dv = dx * dy * dz;
               integral += RetrieveBinContent(bin) * dv;
            } else {
              integral += RetrieveBinContent(bin);
            }
            if (doError) {
               if (width)  igerr2 += GetBinErrorSqUnchecked(bin) * dv * dv;
               else        igerr2 += GetBinErrorSqUnchecked(bin);
            }
         }
      }
   }

   if (doError) error = TMath::Sqrt(igerr2);
   return integral;
}


//______________________________________________________________________________
Double_t TH1::AndersonDarlingTest(const TH1 *h2, Option_t *option) const
{
   //  Statistical test of compatibility in shape between
   //  this histogram and h2, using the Anderson-Darling 2 sample test.
   //  The AD 2 sample test formula are derived from the paper 
   //  F.W Scholz, M.A. Stephens "k-Sample Anderson-Darling Test". 
   //  The test is implemented in root in the ROOT::Math::GoFTest class
   //  It is the same formula ( (6) in the paper), and also shown in this preprint
   //  http://arxiv.org/pdf/0804.0380v1.pdf
   //  Binned data are considered as un-binned data 
   //   with identical observation happening in the bin center. 
   //
   //     option is a character string to specify options
   //         "D" Put out a line of "Debug" printout
   //         "T" Return the normalized A-D test statistic
   // 
   //  Note1: Underflow and overflow are not considered in the test
   //  Note2:  The test works only for un-weighted histogram (i.e. representing counts)
   //  Note3:  The histograms are not required to have the same X axis
   //  Note4:  The test works only for 1-dimensional histograms

   Double_t advalue = 0; 
   Double_t pvalue = AndersonDarlingTest(h2, advalue); 

   TString opt = option;
   opt.ToUpper();
   if (opt.Contains("D") ) {
      printf(" AndersonDarlingTest Prob     = %g, AD TestStatistic  = %g\n",pvalue,advalue);
   } 
   if (opt.Contains("T") ) return advalue; 

   return pvalue;    
}

//______________________________________________________________________________
Double_t TH1::AndersonDarlingTest(const TH1 *h2, Double_t & advalue) const
{
   // Same funciton as above but returning also the test statistic value

   if (GetDimension() != 1 || h2->GetDimension() != 1) {
      Error("AndersonDarlingTest","Histograms must be 1-D");
      return -1; 
   }


   // empty the buffer. Probably we could add as an unbinned test
   if (fBuffer) ((TH1*)this)->BufferEmpty();

   // use the BinData class
   ROOT::Fit::BinData data1; 
   ROOT::Fit::BinData data2;
   
   ROOT::Fit::FillData(data1, this, 0);
   ROOT::Fit::FillData(data2, h2, 0);

   double pvalue; 
   ROOT::Math::GoFTest::AndersonDarling2SamplesTest(data1,data2, pvalue,advalue);

   return pvalue; 
}

//______________________________________________________________________________
Double_t TH1::KolmogorovTest(const TH1 *h2, Option_t *option) const
{
   //  Statistical test of compatibility in shape between
   //  this histogram and h2, using Kolmogorov test.
   //  Note that the KolmogorovTest (KS) test should in theory be used only for unbinned data
   //  and not for binned data as in the case of the histogram (see NOTE 3 below).
   //  So, before using this method blindly, read the NOTE 3.
   //
   //
   //     Default: Ignore under- and overflow bins in comparison
   //
   //     option is a character string to specify options
   //         "U" include Underflows in test  (also for 2-dim)
   //         "O" include Overflows     (also valid for 2-dim)
   //         "N" include comparison of normalizations
   //         "D" Put out a line of "Debug" printout
   //         "M" Return the Maximum Kolmogorov distance instead of prob
   //         "X" Run the pseudo experiments post-processor with the following procedure:
   //             make pseudoexperiments based on random values from the parent
   //             distribution and compare the KS distance of the pseudoexperiment
   //             to the parent distribution. Bin the KS distances in a histogram,
   //             and then take the integral of all the KS values above the value
   //             obtained from the original data to Monte Carlo distribution.
   //             The number of pseudo-experiments nEXPT is currently fixed at 1000.
   //             The function returns the integral.
   //             (thanks to Ben Kilminster to submit this procedure). Note that
   //             this option "X" is much slower.
   //
   //   The returned function value is the probability of test
   //       (much less than one means NOT compatible)
   //
   //  Code adapted by Rene Brun from original HBOOK routine HDIFF
   //
   //  NOTE1
   //  A good description of the Kolmogorov test can be seen at:
   //    http://www.itl.nist.gov/div898/handbook/eda/section3/eda35g.htm
   //
   //  NOTE2
   //  see also alternative function TH1::Chi2Test
   //  The Kolmogorov test is assumed to give better results than Chi2Test
   //  in case of histograms with low statistics.
   //
   //  NOTE3 (Jan Conrad, Fred James)
   //  "The returned value PROB is calculated such that it will be
   //  uniformly distributed between zero and one for compatible histograms,
   //  provided the data are not binned (or the number of bins is very large
   //  compared with the number of events). Users who have access to unbinned
   //  data and wish exact confidence levels should therefore not put their data
   //  into histograms, but should call directly TMath::KolmogorovTest. On
   //  the other hand, since TH1 is a convenient way of collecting data and
   //  saving space, this function has been provided. However, the values of
   //  PROB for binned data will be shifted slightly higher than expected,
   //  depending on the effects of the binning. For example, when comparing two
   //  uniform distributions of 500 events in 100 bins, the values of PROB,
   //  instead of being exactly uniformly distributed between zero and one, have
   //  a mean value of about 0.56. We can apply a useful
   //  rule: As long as the bin width is small compared with any significant
   //  physical effect (for example the experimental resolution) then the binning
   //  cannot have an important effect. Therefore, we believe that for all
   //  practical purposes, the probability value PROB is calculated correctly
   //  provided the user is aware that:
   //     1. The value of PROB should not be expected to have exactly the correct
   //  distribution for binned data.
   //     2. The user is responsible for seeing to it that the bin widths are
   //  small compared with any physical phenomena of interest.
   //     3. The effect of binning (if any) is always to make the value of PROB
   //  slightly too big. That is, setting an acceptance criterion of (PROB>0.05
   //  will assure that at most 5% of truly compatible histograms are rejected,
   //  and usually somewhat less."
   //
   //  Note also that for GoF test of unbinned data ROOT provides also the class
   //  ROOT::Math::GoFTest. The class has also method for doing one sample tests
   //  (i.e. comparing the data with a given distribution).

   TString opt = option;
   opt.ToUpper();

   Double_t prob = 0;
   TH1 *h1 = (TH1*)this;
   if (h2 == 0) return 0;
   const TAxis *axis1 = h1->GetXaxis();
   const TAxis *axis2 = h2->GetXaxis();
   Int_t ncx1   = axis1->GetNbins();
   Int_t ncx2   = axis2->GetNbins();

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

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

   // empty the buffer. Probably we could add as an unbinned test
   if (fBuffer) ((TH1*)this)->BufferEmpty();

   // Check consistency in channel edges
   Double_t difprec = 1e-5;
   Double_t diff1 = TMath::Abs(axis1->GetXmin() - axis2->GetXmin());
   Double_t diff2 = TMath::Abs(axis1->GetXmax() - axis2->GetXmax());
   if (diff1 > difprec || diff2 > difprec) {
      Error("KolmogorovTest","histograms with different binning");
      return 0;
   }

   Bool_t afunc1 = kFALSE;
   Bool_t afunc2 = kFALSE;
   Double_t sum1 = 0, sum2 = 0;
   Double_t ew1, ew2, w1 = 0, w2 = 0;
   Int_t bin;
   Int_t ifirst = 1;
   Int_t ilast = ncx1;
   // integral of all bins (use underflow/overflow if option)
   if (opt.Contains("U")) ifirst = 0;
   if (opt.Contains("O")) ilast = ncx1 +1;
   for (bin = ifirst; bin <= ilast; bin++) {
      sum1 += h1->RetrieveBinContent(bin);
      sum2 += h2->RetrieveBinContent(bin);
      ew1   = h1->GetBinError(bin);
      ew2   = h2->GetBinError(bin);
      w1   += ew1*ew1;
      w2   += ew2*ew2;
   }
   if (sum1 == 0) {
      Error("KolmogorovTest","Histogram1 %s integral is zero\n",h1->GetName());
      return 0;
   }
   if (sum2 == 0) {
      Error("KolmogorovTest","Histogram2 %s integral is zero\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;
   }


   Double_t s1 = 1/sum1;
   Double_t s2 = 1/sum2;

   // Find largest difference for Kolmogorov Test
   Double_t dfmax =0, rsum1 = 0, rsum2 = 0;

   for (bin=ifirst;bin<=ilast;bin++) {
      rsum1 += s1*h1->RetrieveBinContent(bin);
      rsum2 += s2*h2->RetrieveBinContent(bin);
      dfmax = TMath::Max(dfmax,TMath::Abs(rsum1-rsum2));
   }

   // Get Kolmogorov probability
   Double_t z, prb1=0, prb2=0, prb3=0;

   // case h1 is exact (has zero errors)
  if  (afunc1)
      z = dfmax*TMath::Sqrt(esum2);
  // case h2 has zero errors
  else if (afunc2)
      z = dfmax*TMath::Sqrt(esum1);
  else
     // for comparison between two data sets
     z = dfmax*TMath::Sqrt(esum1*esum2/(esum1+esum2));

   prob = TMath::KolmogorovProb(z);

   // 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 = prob;
      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 (prob > 0 && prb2 > 0) prob *= prb2*(1-TMath::Log(prob*prb2));
      else                      prob = 0;
   }
   // X option. Pseudo-experiments post-processor to determine KS probability
   const Int_t nEXPT = 1000;
   if (opt.Contains("X") && !(afunc1 || afunc2 ) ) {
      Double_t dSEXPT;
      TH1 *hExpt = (TH1*)(gDirectory ? gDirectory->CloneObject(this,kFALSE) : gROOT->CloneObject(this,kFALSE));
      // make nEXPT experiments (this should be a parameter)
      prb3 = 0;
      for (Int_t i=0; i < nEXPT; i++) {
         hExpt->Reset();
         hExpt->FillRandom(h1,(Int_t)esum2);
         dSEXPT = KolmogorovTest(hExpt,"M");
         if (dSEXPT>dfmax) prb3 += 1.0;
      }
      prb3 /= (Double_t)nEXPT;
      delete hExpt;
   }

   // debug printout
   if (opt.Contains("D")) {
      printf(" Kolmo Prob  h1 = %s, sum bin content =%g  effective entries =%g\n",h1->GetName(),sum1,esum1);
      printf(" Kolmo Prob  h2 = %s, sum bin content =%g  effective entries =%g\n",h2->GetName(),sum2,esum2);
      printf(" Kolmo Prob     = %g, Max Dist = %g\n",prob,dfmax);
      if (opt.Contains("N"))
         printf(" Kolmo Prob     = %f for shape alone, =%f for normalisation alone\n",prb1,prb2);
      if (opt.Contains("X"))
         printf(" Kolmo Prob     = %f with %d pseudo-experiments\n",prb3,nEXPT);
   }
   // 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;
   else if(opt.Contains("X")) return prb3;
   else                       return prob;
}


//______________________________________________________________________________
void TH1::SetContent(const Double_t *content)
{
   // Replace bin contents by the contents of array content
   fEntries = fNcells;
   fTsumw = 0;
   for (Int_t i = 0; i < fNcells; ++i) UpdateBinContent(i, content[i]);
}


//______________________________________________________________________________
Int_t TH1::GetContour(Double_t *levels)
{
   //  Return contour values into array levels if pointer levels is non zero
   //
   //  The function returns the number of contour levels.
   //  see GetContourLevel to return one contour only
   //

   Int_t nlevels = fContour.fN;
   if (levels) {
      if (nlevels == 0) {
         nlevels = 20;
         SetContour(nlevels);
      } else {
         if (TestBit(kUserContour) == 0) SetContour(nlevels);
      }
      for (Int_t level=0; level<nlevels; level++) levels[level] = fContour.fArray[level];
   }
   return nlevels;
}


//______________________________________________________________________________
Double_t TH1::GetContourLevel(Int_t level) const
{
   // Return value of contour number level
   // use GetContour to return the array of all contour levels

   return (level >= 0 && level < fContour.fN) ? fContour.fArray[level] : 0.0;
}


//______________________________________________________________________________
Double_t TH1::GetContourLevelPad(Int_t level) const
{
   // Return the value of contour number "level" in Pad coordinates ie: if the Pad
   // is in log scale along Z it returns le log of the contour level value.
   // see GetContour to return the array of all contour levels

   if (level <0 || level >= fContour.fN) return 0;
   Double_t zlevel = fContour.fArray[level];

   // In case of user defined contours and Pad in log scale along Z,
   // fContour.fArray doesn't contain the log of the contour whereas it does
   // in case of equidistant contours.
   if (gPad && gPad->GetLogz() && TestBit(kUserContour)) {
      if (zlevel <= 0) return 0;
      zlevel = TMath::Log10(zlevel);
   }
   return zlevel;
}


//______________________________________________________________________________
void TH1::SetBuffer(Int_t buffersize, Option_t * /*option*/)
{
   // set the maximum number of entries to be kept in the buffer

   if (fBuffer) {
      BufferEmpty();
      delete [] fBuffer;
      fBuffer = 0;
   }
   if (buffersize <= 0) {
      fBufferSize = 0;
      return;
   }
   if (buffersize < 100) buffersize = 100;
   fBufferSize = 1 + buffersize*(fDimension+1);
   fBuffer = new Double_t[fBufferSize];
   memset(fBuffer,0,sizeof(Double_t)*fBufferSize);
}


//______________________________________________________________________________
void TH1::SetContour(Int_t  nlevels, const Double_t *levels)
{
   //  Set the number and values of contour levels.
   //
   //  By default the number of contour levels is set to 20. The contours values
   //  in the array "levels" should be specified in increasing order.
   //
   //  if argument levels = 0 or missing, equidistant contours are computed

   Int_t level;
   ResetBit(kUserContour);
   if (nlevels <=0 ) {
      fContour.Set(0);
      return;
   }
   fContour.Set(nlevels);

   //   -  Contour levels are specified
   if (levels) {
      SetBit(kUserContour);
      for (level=0; level<nlevels; level++) fContour.fArray[level] = levels[level];
   } else {
      //   - contour levels are computed automatically as equidistant contours
      Double_t zmin = GetMinimum();
      Double_t zmax = GetMaximum();
      if ((zmin == zmax) && (zmin != 0)) {
         zmax += 0.01*TMath::Abs(zmax);
         zmin -= 0.01*TMath::Abs(zmin);
      }
      Double_t dz   = (zmax-zmin)/Double_t(nlevels);
      if (gPad && gPad->GetLogz()) {
         if (zmax <= 0) return;
         if (zmin <= 0) zmin = 0.001*zmax;
         zmin = TMath::Log10(zmin);
         zmax = TMath::Log10(zmax);
         dz   = (zmax-zmin)/Double_t(nlevels);
      }
      for (level=0; level<nlevels; level++) {
         fContour.fArray[level] = zmin + dz*Double_t(level);
      }
   }
}


//______________________________________________________________________________
void TH1::SetContourLevel(Int_t level, Double_t value)
{
   // Set value for one contour level.

   if (level < 0 || level >= fContour.fN) return;
   SetBit(kUserContour);
   fContour.fArray[level] = value;
}


//______________________________________________________________________________
Double_t TH1::GetMaximum(Double_t maxval) const
{
   //  Return maximum value smaller than maxval of bins in the range,
   //  unless the value has been overridden by TH1::SetMaximum,
   //  in which case it returns that value. (This happens, for example,
   //  when the histogram is drawn and the y or z axis limits are changed
   //
   //  To get the maximum value of bins in the histogram regardless of
   //  whether the value has been overridden, use
   //      h->GetBinContent(h->GetMaximumBin())

   if (fMaximum != -1111) return fMaximum;

   // empty the buffer
   if (fBuffer) ((TH1*)this)->BufferEmpty();

   Int_t bin, binx, biny, binz;
   Int_t xfirst  = fXaxis.GetFirst();
   Int_t xlast   = fXaxis.GetLast();
   Int_t yfirst  = fYaxis.GetFirst();
   Int_t ylast   = fYaxis.GetLast();
   Int_t zfirst  = fZaxis.GetFirst();
   Int_t zlast   = fZaxis.GetLast();
   Double_t maximum = -FLT_MAX, value;
   for (binz=zfirst;binz<=zlast;binz++) {
      for (biny=yfirst;biny<=ylast;biny++) {
         for (binx=xfirst;binx<=xlast;binx++) {
            bin = GetBin(binx,biny,binz);
            value = RetrieveBinContent(bin);
            if (value > maximum && value < maxval) maximum = value;
         }
      }
   }
   return maximum;
}


//______________________________________________________________________________
Int_t TH1::GetMaximumBin() const
{
   // Return location of bin with maximum value in the range.

   Int_t locmax, locmay, locmaz;
   return GetMaximumBin(locmax, locmay, locmaz);
}


//______________________________________________________________________________
Int_t TH1::GetMaximumBin(Int_t &locmax, Int_t &locmay, Int_t &locmaz) const
{
   // Return location of bin with maximum value in the range.

      // empty the buffer
   if (fBuffer) ((TH1*)this)->BufferEmpty();

   Int_t bin, binx, biny, binz;
   Int_t locm;
   Int_t xfirst  = fXaxis.GetFirst();
   Int_t xlast   = fXaxis.GetLast();
   Int_t yfirst  = fYaxis.GetFirst();
   Int_t ylast   = fYaxis.GetLast();
   Int_t zfirst  = fZaxis.GetFirst();
   Int_t zlast   = fZaxis.GetLast();
   Double_t maximum = -FLT_MAX, value;
   locm = locmax = locmay = locmaz = 0;
   for (binz=zfirst;binz<=zlast;binz++) {
      for (biny=yfirst;biny<=ylast;biny++) {
         for (binx=xfirst;binx<=xlast;binx++) {
            bin = GetBin(binx,biny,binz);
            value = RetrieveBinContent(bin);
            if (value > maximum) {
               maximum = value;
               locm    = bin;
               locmax  = binx;
               locmay  = biny;
               locmaz  = binz;
            }
         }
      }
   }
   return locm;
}


//______________________________________________________________________________
Double_t TH1::GetMinimum(Double_t minval) const
{
   //  Return minimum value larger than minval of bins in the range,
   //  unless the value has been overridden by TH1::SetMinimum,
   //  in which case it returns that value. (This happens, for example,
   //  when the histogram is drawn and the y or z axis limits are changed
   //
   //  To get the minimum value of bins in the histogram regardless of
   //  whether the value has been overridden, use
   //     h->GetBinContent(h->GetMinimumBin())

   if (fMinimum != -1111) return fMinimum;

   // empty the buffer
   if (fBuffer) ((TH1*)this)->BufferEmpty();

   Int_t bin, binx, biny, binz;
   Int_t xfirst  = fXaxis.GetFirst();
   Int_t xlast   = fXaxis.GetLast();
   Int_t yfirst  = fYaxis.GetFirst();
   Int_t ylast   = fYaxis.GetLast();
   Int_t zfirst  = fZaxis.GetFirst();
   Int_t zlast   = fZaxis.GetLast();
   Double_t minimum=FLT_MAX, value;
   for (binz=zfirst;binz<=zlast;binz++) {
      for (biny=yfirst;biny<=ylast;biny++) {
         for (binx=xfirst;binx<=xlast;binx++) {
            bin = GetBin(binx,biny,binz);
            value = RetrieveBinContent(bin);
            if (value < minimum && value > minval) minimum = value;
         }
      }
   }
   return minimum;
}


//______________________________________________________________________________
Int_t TH1::GetMinimumBin() const
{
   // Return location of bin with minimum value in the range.

   Int_t locmix, locmiy, locmiz;
   return GetMinimumBin(locmix, locmiy, locmiz);
}


//______________________________________________________________________________
Int_t TH1::GetMinimumBin(Int_t &locmix, Int_t &locmiy, Int_t &locmiz) const
{
   // Return location of bin with minimum value in the range.

      // empty the buffer
   if (fBuffer) ((TH1*)this)->BufferEmpty();
   
   Int_t bin, binx, biny, binz;
   Int_t locm;
   Int_t xfirst  = fXaxis.GetFirst();
   Int_t xlast   = fXaxis.GetLast();
   Int_t yfirst  = fYaxis.GetFirst();
   Int_t ylast   = fYaxis.GetLast();
   Int_t zfirst  = fZaxis.GetFirst();
   Int_t zlast   = fZaxis.GetLast();
   Double_t minimum = FLT_MAX, value;
   locm = locmix = locmiy = locmiz = 0;
   for (binz=zfirst;binz<=zlast;binz++) {
      for (biny=yfirst;biny<=ylast;biny++) {
         for (binx=xfirst;binx<=xlast;binx++) {
            bin = GetBin(binx,biny,binz);
            value = RetrieveBinContent(bin);
            if (value < minimum) {
               minimum = value;
               locm    = bin;
               locmix  = binx;
               locmiy  = biny;
               locmiz  = binz;
            }
         }
      }
   }
   return locm;
}


//______________________________________________________________________________
void TH1::SetBins(Int_t nx, Double_t xmin, Double_t xmax)
{
   // Redefine  x axis parameters.
   //
   // The X axis parameters are modified.
   // The bins content array is resized
   // if errors (Sumw2) the errors array is resized
   // The previous bin contents are lost
   // To change only the axis limits, see TAxis::SetRange

   if (GetDimension() != 1) {
      Error("SetBins","Operation only valid for 1-d histograms");
      return;
   }
   fXaxis.SetRange(0,0);
   fXaxis.Set(nx,xmin,xmax);
   fYaxis.Set(1,0,1);
   fZaxis.Set(1,0,1);
   fNcells = nx+2;
   SetBinsLength(fNcells);
   if (fSumw2.fN) {
      fSumw2.Set(fNcells);
   }
}


//______________________________________________________________________________
void TH1::SetBins(Int_t nx, const Double_t *xBins)
{
   // Redefine  x axis parameters with variable bin sizes.
   //
   // The X axis parameters are modified.
   // The bins content array is resized
   // if errors (Sumw2) the errors array is resized
   // The previous bin contents are lost
   // To change only the axis limits, see TAxis::SetRange
   // xBins is supposed to be of length nx+1
   if (GetDimension() != 1) {
      Error("SetBins","Operation only valid for 1-d histograms");
      return;
   }
   fXaxis.SetRange(0,0);
   fXaxis.Set(nx,xBins);
   fYaxis.Set(1,0,1);
   fZaxis.Set(1,0,1);
   fNcells = nx+2;
   SetBinsLength(fNcells);
   if (fSumw2.fN) {
      fSumw2.Set(fNcells);
   }
}


//______________________________________________________________________________
void TH1::SetBins(Int_t nx, Double_t xmin, Double_t xmax, Int_t ny, Double_t ymin, Double_t ymax)
{
   // Redefine  x and y axis parameters.
   //
   // The X and Y axis parameters are modified.
   // The bins content array is resized
   // if errors (Sumw2) the errors array is resized
   // The previous bin contents are lost
   // To change only the axis limits, see TAxis::SetRange

   if (GetDimension() != 2) {
      Error("SetBins","Operation only valid for 2-D histograms");
      return;
   }
   fXaxis.SetRange(0,0);
   fYaxis.SetRange(0,0);
   fXaxis.Set(nx,xmin,xmax);
   fYaxis.Set(ny,ymin,ymax);
   fZaxis.Set(1,0,1);
   fNcells = (nx+2)*(ny+2);
   SetBinsLength(fNcells);
   if (fSumw2.fN) {
      fSumw2.Set(fNcells);
   }
}


//______________________________________________________________________________
void TH1::SetBins(Int_t nx, const Double_t *xBins, Int_t ny, const Double_t *yBins)
{
   // Redefine  x and y axis parameters with variable bin sizes.
   //
   // The X and Y axis parameters are modified.
   // The bins content array is resized
   // if errors (Sumw2) the errors array is resized
   // The previous bin contents are lost
   // To change only the axis limits, see TAxis::SetRange
   // xBins is supposed to be of length nx+1, yBins is supposed to be of length ny+1

   if (GetDimension() != 2) {
      Error("SetBins","Operation only valid for 2-D histograms");
      return;
   }
   fXaxis.SetRange(0,0);
   fYaxis.SetRange(0,0);
   fXaxis.Set(nx,xBins);
   fYaxis.Set(ny,yBins);
   fZaxis.Set(1,0,1);
   fNcells = (nx+2)*(ny+2);
   SetBinsLength(fNcells);
   if (fSumw2.fN) {
      fSumw2.Set(fNcells);
   }
}


//______________________________________________________________________________
void TH1::SetBins(Int_t nx, Double_t xmin, Double_t xmax, Int_t ny, Double_t ymin, Double_t ymax, Int_t nz, Double_t zmin, Double_t zmax)
{
   // Redefine  x, y and z axis parameters.
   //
   // The X, Y and Z axis parameters are modified.
   // The bins content array is resized
   // if errors (Sumw2) the errors array is resized
   // The previous bin contents are lost
   // To change only the axis limits, see TAxis::SetRange

   if (GetDimension() != 3) {
      Error("SetBins","Operation only valid for 3-D histograms");
      return;
   }
   fXaxis.SetRange(0,0);
   fYaxis.SetRange(0,0);
   fZaxis.SetRange(0,0);
   fXaxis.Set(nx,xmin,xmax);
   fYaxis.Set(ny,ymin,ymax);
   fZaxis.Set(nz,zmin,zmax);
   fNcells = (nx+2)*(ny+2)*(nz+2);
   SetBinsLength(fNcells);
   if (fSumw2.fN) {
      fSumw2.Set(fNcells);
   }
}


//______________________________________________________________________________
void TH1::SetBins(Int_t nx, const Double_t *xBins, Int_t ny, const Double_t *yBins, Int_t nz, const Double_t *zBins)
{
   // Redefine  x, y and z axis parameters with variable bin sizes.
   //
   // The X, Y and Z axis parameters are modified.
   // The bins content array is resized
   // if errors (Sumw2) the errors array is resized
   // The previous bin contents are lost
   // To change only the axis limits, see TAxis::SetRange
   // xBins is supposed to be of length nx+1, yBins is supposed to be of length ny+1,
   // zBins is supposed to be of length nz+1

   if (GetDimension() != 3) {
      Error("SetBins","Operation only valid for 3-D histograms");
      return;
   }
   fXaxis.SetRange(0,0);
   fYaxis.SetRange(0,0);
   fZaxis.SetRange(0,0);
   fXaxis.Set(nx,xBins);
   fYaxis.Set(ny,yBins);
   fZaxis.Set(nz,zBins);
   fNcells = (nx+2)*(ny+2)*(nz+2);
   SetBinsLength(fNcells);
   if (fSumw2.fN) {
      fSumw2.Set(fNcells);
   }
}


//______________________________________________________________________________
void TH1::SetDirectory(TDirectory *dir)
{
   // By default when an histogram is created, it is added to the list
   // of histogram objects in the current directory in memory.
   // Remove reference to this histogram from current directory and add
   // reference to new directory dir. dir can be 0 in which case the
   // histogram does not belong to any directory.

   if (fDirectory == dir) return;
   if (fDirectory) fDirectory->Remove(this);
   fDirectory = dir;
   if (fDirectory) fDirectory->Append(this);
}


//______________________________________________________________________________
void TH1::SetError(const Double_t *error)
{
   // Replace bin errors by values in array error.

   for (Int_t i = 0; i < fNcells; ++i) SetBinError(i, error[i]);
}


//______________________________________________________________________________
void TH1::SetName(const char *name)
{
   // Change the name of this histogram
   //

   //  Histograms are named objects in a THashList.
   //  We must update the hashlist if we change the name
   //  We protect this operation
   R__LOCKGUARD2(gROOTMutex);
   if (fDirectory) fDirectory->Remove(this);
   fName = name;
   if (fDirectory) fDirectory->Append(this);
}


//______________________________________________________________________________
void TH1::SetNameTitle(const char *name, const char *title)
{
   // Change the name and title of this histogram

   //  Histograms are named objects in a THashList.
   //  We must update the hashlist if we change the name
   SetName(name);
   SetTitle(title);
}


//______________________________________________________________________________
void TH1::SetStats(Bool_t stats)
{
   // Set statistics option on/off
   //
   //  By default, the statistics box is drawn.
   //  The paint options can be selected via gStyle->SetOptStats.
   //  This function sets/resets the kNoStats bin in the histogram object.
   //  It has priority over the Style option.

   ResetBit(kNoStats);
   if (!stats) {
      SetBit(kNoStats);
      //remove the "stats" object from the list of functions
      if (fFunctions) {
         TObject *obj = fFunctions->FindObject("stats");
         if (obj) {
            fFunctions->Remove(obj);
            delete obj;
         }
      }
   }
}


//______________________________________________________________________________
void TH1::Sumw2(Bool_t flag)
{
   // Create structure to store sum of squares of weights.
   //
   //     if histogram is already filled, the sum of squares of weights
   //     is filled with the existing bin contents
   //
   //     The error per bin will be computed as sqrt(sum of squares of weight)
   //     for each bin.
   //
   //  This function is automatically called when the histogram is created
   //  if the static function TH1::SetDefaultSumw2 has been called before.
   //  If flag = false the structure is deleted

   if (!flag) {
      // clear the array if existing - do nothing otherwise
      if (fSumw2.fN > 0 ) fSumw2.Set(0);
      return;
   }

   if (fSumw2.fN == fNcells) {
      if (!fgDefaultSumw2 )
         Warning("Sumw2","Sum of squares of weights structure already created");
      return;
   }

   fSumw2.Set(fNcells);

   // empty the buffer
   if (fBuffer) BufferEmpty();

   if (fEntries > 0)
      for (Int_t i = 0; i < fNcells; ++i)
         fSumw2.fArray[i] = TMath::Abs(RetrieveBinContent(i));
}


//______________________________________________________________________________
TF1 *TH1::GetFunction(const char *name) const
{
   // Return pointer to function with name.
   //
   //
   // Functions such as TH1::Fit store the fitted function in the list of
   // functions of this histogram.

   return (TF1*)fFunctions->FindObject(name);
}


//______________________________________________________________________________
Double_t TH1::GetBinError(Int_t bin) const
{
   // Return value of error associated to bin number bin.
   //
   //    if the sum of squares of weights has been defined (via Sumw2),
   //    this function returns the sqrt(sum of w2).
   //    otherwise it returns the sqrt(contents) for this bin.

   if (bin < 0) bin = 0;
   if (bin >= fNcells) bin = fNcells-1;
   if (fBuffer) ((TH1*)this)->BufferEmpty();
   if (fSumw2.fN) return TMath::Sqrt(fSumw2.fArray[bin]);

   return TMath::Sqrt(TMath::Abs(RetrieveBinContent(bin)));
}


//______________________________________________________________________________
Double_t TH1::GetBinErrorLow(Int_t bin) const
{
   // Return lower error associated to bin number bin.
   //
   //    The error will depend on the statistic option used will return
   //     the binContent - lower interval value

   if (fBinStatErrOpt == kNormal || fSumw2.fN) return GetBinError(bin);
   if (bin < 0) bin = 0;
   if (bin >= fNcells) bin = fNcells-1;
   if (fBuffer) ((TH1*)this)->BufferEmpty();

   Double_t alpha = 1.- 0.682689492;
   if (fBinStatErrOpt == kPoisson2) alpha = 0.05;

   Double_t c = RetrieveBinContent(bin);
   Int_t n = int(c);
   if (n < 0) {
      Warning("GetBinErrorLow","Histogram has negative bin content-force usage to normal errors");
      ((TH1*)this)->fBinStatErrOpt = kNormal;
      return GetBinError(bin);
   }

   if (n == 0) return 0;
   return c - ROOT::Math::gamma_quantile( alpha/2, n, 1.);
}


//______________________________________________________________________________
Double_t TH1::GetBinErrorUp(Int_t bin) const
{
   // Return upper error associated to bin number bin.
   //
   //    The error will depend on the statistic option used will return
   //     the binContent - upper interval value

   if (fBinStatErrOpt == kNormal || fSumw2.fN) return GetBinError(bin);
   if (bin < 0) bin = 0;
   if (bin >= fNcells) bin = fNcells-1;
   if (fBuffer) ((TH1*)this)->BufferEmpty();

   Double_t alpha = 1.- 0.682689492;
   if (fBinStatErrOpt == kPoisson2) alpha = 0.05;

   Double_t c = RetrieveBinContent(bin);
   Int_t n = int(c);
   if (n < 0) {
      Warning("GetBinErrorUp","Histogram has negative bin content-force usage to normal errors");
      ((TH1*)this)->fBinStatErrOpt = kNormal;
      return GetBinError(bin);
   }

   // for N==0 return an upper limit at 0.68 or (1-alpha)/2 ?
   // decide to return always (1-alpha)/2 upper interval
   //if (n == 0) return ROOT::Math::gamma_quantile_c(alpha,n+1,1);
   return ROOT::Math::gamma_quantile_c( alpha/2, n+1, 1) - c;
}

//L.M. These following getters are useless and should be probably deprecated
//______________________________________________________________________________
Double_t TH1::GetBinCenter(Int_t bin) const
{
   // return bin center for 1D historam
   // Better to use h1.GetXaxis().GetBinCenter(bin)

   if (fDimension == 1) return  fXaxis.GetBinCenter(bin);
   Error("GetBinCenter","Invalid method for a %d-d histogram - return a NaN",fDimension);
   return TMath::QuietNaN();
}

//______________________________________________________________________________
Double_t TH1::GetBinLowEdge(Int_t bin) const
{
   // return bin lower edge for 1D historam
   // Better to use h1.GetXaxis().GetBinLowEdge(bin)

   if (fDimension == 1) return  fXaxis.GetBinLowEdge(bin);
   Error("GetBinLowEdge","Invalid method for a %d-d histogram - return a NaN",fDimension);
   return TMath::QuietNaN();
}

//______________________________________________________________________________
Double_t TH1::GetBinWidth(Int_t bin) const
{
   // return bin width for 1D historam
   // Better to use h1.GetXaxis().GetBinWidth(bin)

   if (fDimension == 1) return  fXaxis.GetBinWidth(bin);
   Error("GetBinWidth","Invalid method for a %d-d histogram - return a NaN",fDimension);
   return TMath::QuietNaN();
}

//______________________________________________________________________________
void TH1::GetCenter(Double_t *center) const
{
   // Fill array with center of bins for 1D histogram
   // Better to use h1.GetXaxis().GetCenter(center)

   if (fDimension == 1) {
      fXaxis.GetCenter(center);
      return;
   }
   Error("GetCenter","Invalid method for a %d-d histogram ",fDimension);
}

//______________________________________________________________________________
void TH1::GetLowEdge(Double_t *edge) const
{
   // Fill array with low edge of bins for 1D histogram
   // Better to use h1.GetXaxis().GetLowEdge(edge)

   if (fDimension == 1) {
      fXaxis.GetLowEdge(edge);
      return;
   }
   Error("GetLowEdge","Invalid method for a %d-d histogram ",fDimension);
}

//______________________________________________________________________________
void TH1::SetBinError(Int_t bin, Double_t error)
{
   // see convention for numbering bins in TH1::GetBin
   if (!fSumw2.fN) Sumw2();
   if (bin < 0 || bin>= fSumw2.fN) return;
   fSumw2.fArray[bin] = error * error;
}


//______________________________________________________________________________
void TH1::SetBinContent(Int_t bin, Double_t content)
{
   // Set bin content
   // see convention for numbering bins in TH1::GetBin
   // In case the bin number is greater than the number of bins and
   // the timedisplay option is set or CanExtendAllAxes(),
   // the number of bins is automatically doubled to accommodate the new bin

   fEntries++;
   fTsumw = 0;
   if (bin < 0) return;
   if (bin >= fNcells-1) {
      if (fXaxis.GetTimeDisplay() || CanExtendAllAxes() ) {
         while (bin >=  fNcells-1)  LabelsInflate();
      } else {
         if (bin == fNcells-1) UpdateBinContent(bin, content);
         return;
      }
   }
   UpdateBinContent(bin, content);
}


//______________________________________________________________________________
void TH1::SetBinError(Int_t binx, Int_t biny, Double_t error)
{
   // see convention for numbering bins in TH1::GetBin
   if (binx < 0 || binx > fXaxis.GetNbins() + 1) return;
   if (biny < 0 || biny > fYaxis.GetNbins() + 1) return;
   SetBinError(GetBin(binx, biny), error);
}


//______________________________________________________________________________
void TH1::SetBinError(Int_t binx, Int_t biny, Int_t binz, Double_t error)
{
   // see convention for numbering bins in TH1::GetBin
   if (binx < 0 || binx > fXaxis.GetNbins() + 1) return;
   if (biny < 0 || biny > fYaxis.GetNbins() + 1) return;
   if (binz < 0 || binz > fZaxis.GetNbins() + 1) return;
   SetBinError(GetBin(binx, biny, binz), error);
}


//______________________________________________________________________________
TH1 *TH1::ShowBackground(Int_t niter, Option_t *option)
{
   //   This function calculates the background spectrum in this histogram.
   //   The background is returned as a histogram.
   //
   //   Function parameters:
   //   -niter, number of iterations (default value = 2)
   //      Increasing niter make the result smoother and lower.
   //   -option: may contain one of the following options
   //      - to set the direction parameter
   //        "BackDecreasingWindow". By default the direction is BackIncreasingWindow
   //      - filterOrder-order of clipping filter,  (default "BackOrder2"
   //                  -possible values= "BackOrder4"
   //                                    "BackOrder6"
   //                                    "BackOrder8"
   //      - "nosmoothing"- if selected, the background is not smoothed
   //           By default the background is smoothed.
   //      - smoothWindow-width of smoothing window, (default is "BackSmoothing3")
   //                  -possible values= "BackSmoothing5"
   //                                    "BackSmoothing7"
   //                                    "BackSmoothing9"
   //                                    "BackSmoothing11"
   //                                    "BackSmoothing13"
   //                                    "BackSmoothing15"
   //      - "nocompton"- if selected the estimation of Compton edge
   //                  will be not be included   (by default the compton estimation is set)
   //      - "same" : if this option is specified, the resulting background
   //                 histogram is superimposed on the picture in the current pad.
   //                 This option is given by default.
   //
   //  NOTE that the background is only evaluated in the current range of this histogram.
   //  i.e., if this has a bin range (set via h->GetXaxis()->SetRange(binmin, binmax),
   //  the returned histogram will be created with the same number of bins
   //  as this input histogram, but only bins from binmin to binmax will be filled
   //  with the estimated background.
   //


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


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

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



//______________________________________________________________________________
TH1* TH1::TransformHisto(TVirtualFFT *fft, TH1* h_output,  Option_t *option)
{
   //For a given transform (first parameter), fills the histogram (second parameter)
   //with the transform output data, specified in the third parameter
   //If the 2nd parameter h_output is empty, a new histogram (TH1D or TH2D) is created
   //and the user is responsible for deleting it.
   // Available options:
   //   "RE" - real part of the output
   //   "IM" - imaginary part of the output
   //   "MAG" - magnitude of the output
   //   "PH"  - phase of the output

   if (!fft ||  !fft->GetN() ) {
      ::Error("TransformHisto","Invalid FFT transform class");
      return 0;
   }

   if (fft->GetNdim()>2){
      ::Error("TransformHisto","Only 1d and 2D transform are supported");
      return 0;
   }
   Int_t binx,biny;
   TString opt = option;
   opt.ToUpper();
   Int_t *n = fft->GetN();
   TH1 *hout=0;
   if (h_output) {
      hout = h_output;
   }
   else {
      TString name = TString::Format("out_%s", opt.Data());
      if (fft->GetNdim()==1)
         hout = new TH1D(name, name,n[0], 0, n[0]);
      else if (fft->GetNdim()==2)
         hout = new TH2D(name, name, n[0], 0, n[0], n[1], 0, n[1]);
   }
   R__ASSERT(hout != 0);
   TString type=fft->GetType();
   Int_t ind[2];
   if (opt.Contains("RE")){
      if (type.Contains("2C") || type.Contains("2HC")) {
         Double_t re, im;
         for (binx = 1; binx<=hout->GetNbinsX(); binx++) {
            for (biny=1; biny<=hout->GetNbinsY(); biny++) {
               ind[0] = binx-1; ind[1] = biny-1;
               fft->GetPointComplex(ind, re, im);
               hout->SetBinContent(binx, biny, re);
            }
         }
      } else {
         for (binx = 1; binx<=hout->GetNbinsX(); binx++) {
            for (biny=1; biny<=hout->GetNbinsY(); biny++) {
               ind[0] = binx-1; ind[1] = biny-1;
               hout->SetBinContent(binx, biny, fft->GetPointReal(ind));
            }
         }
      }
   }
   if (opt.Contains("IM")) {
      if (type.Contains("2C") || type.Contains("2HC")) {
         Double_t re, im;
         for (binx = 1; binx<=hout->GetNbinsX(); binx++) {
            for (biny=1; biny<=hout->GetNbinsY(); biny++) {
               ind[0] = binx-1; ind[1] = biny-1;
               fft->GetPointComplex(ind, re, im);
               hout->SetBinContent(binx, biny, im);
            }
         }
      } else {
         ::Error("TransformHisto","No complex numbers in the output");
         return 0;
      }
   }
   if (opt.Contains("MA")) {
      if (type.Contains("2C") || type.Contains("2HC")) {
         Double_t re, im;
         for (binx = 1; binx<=hout->GetNbinsX(); binx++) {
            for (biny=1; biny<=hout->GetNbinsY(); biny++) {
               ind[0] = binx-1; ind[1] = biny-1;
               fft->GetPointComplex(ind, re, im);
               hout->SetBinContent(binx, biny, TMath::Sqrt(re*re + im*im));
            }
         }
      } else {
         for (binx = 1; binx<=hout->GetNbinsX(); binx++) {
            for (biny=1; biny<=hout->GetNbinsY(); biny++) {
               ind[0] = binx-1; ind[1] = biny-1;
               hout->SetBinContent(binx, biny, TMath::Abs(fft->GetPointReal(ind)));
            }
         }
      }
   }
   if (opt.Contains("PH")) {
      if (type.Contains("2C") || type.Contains("2HC")){
         Double_t re, im, ph;
         for (binx = 1; binx<=hout->GetNbinsX(); binx++){
            for (biny=1; biny<=hout->GetNbinsY(); biny++){
               ind[0] = binx-1; ind[1] = biny-1;
               fft->GetPointComplex(ind, re, im);
               if (TMath::Abs(re) > 1e-13){
                  ph = TMath::ATan(im/re);
                  //find the correct quadrant
                  if (re<0 && im<0)
                     ph -= TMath::Pi();
                  if (re<0 && im>=0)
                     ph += TMath::Pi();
               } else {
                  if (TMath::Abs(im) < 1e-13)
                     ph = 0;
                  else if (im>0)
                     ph = TMath::Pi()*0.5;
                  else
                     ph = -TMath::Pi()*0.5;
               }
               hout->SetBinContent(binx, biny, ph);
            }
         }
      } else {
         printf("Pure real output, no phase");
         return 0;
      }
   }

   return hout;
}


//______________________________________________________________________________
Double_t TH1::RetrieveBinContent(Int_t) const
{
   // raw retrieval of bin content on internal data structure
   // see convention for numbering bins in TH1::GetBin
   AbstractMethod("RetrieveBinContent");
   return 0;
}


//______________________________________________________________________________
void TH1::UpdateBinContent(Int_t, Double_t)
{
   // raw update of bin content on internal data structure
   // see convention for numbering bins in TH1::GetBin
   AbstractMethod("UpdateBinContent");
}


//______________________________________________________________________________
//                     TH1C methods
// TH1C : histograms with one byte per channel.   Maximum bin content = 127
//______________________________________________________________________________

ClassImp(TH1C)


//______________________________________________________________________________
TH1C::TH1C(): TH1(), TArrayC()
{
   // Constructor.

   fDimension = 1;
   SetBinsLength(3);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1C::TH1C(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
: TH1(name,title,nbins,xlow,xup)
{
   // Create a 1-Dim histogram with fix bins of type char (one byte per channel)
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayC::Set(fNcells);

   if (xlow >= xup) SetBuffer(fgBufferSize);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1C::TH1C(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
: TH1(name,title,nbins,xbins)
{
   // Create a 1-Dim histogram with variable bins of type char (one byte per channel)
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayC::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1C::TH1C(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
: TH1(name,title,nbins,xbins)
{
   // Create a 1-Dim histogram with variable bins of type char (one byte per channel)
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayC::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


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


//______________________________________________________________________________
TH1C::TH1C(const TH1C &h1c) : TH1(), TArrayC()
{
   // Copy constructor.

   ((TH1C&)h1c).Copy(*this);
}


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

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


//______________________________________________________________________________
void TH1C::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 TH1C::Copy(TObject &newth1) const
{
   // Copy this to newth1

   TH1::Copy(newth1);
}


//______________________________________________________________________________
void TH1C::Reset(Option_t *option)
{
   // Reset.

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


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

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


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

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



//______________________________________________________________________________
TH1C operator*(Double_t c1, const TH1C &h1)
{
   // Operator *

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


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

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


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

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


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

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


//______________________________________________________________________________
TH1C operator/(const TH1C &h1, const TH1C &h2)
{
   // Operator /

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



//______________________________________________________________________________
//                     TH1S methods
// TH1S : histograms with one short per channel.  Maximum bin content = 32767
//______________________________________________________________________________

ClassImp(TH1S)


//______________________________________________________________________________
TH1S::TH1S(): TH1(), TArrayS()
{
   // Constructor.

   fDimension = 1;
   SetBinsLength(3);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1S::TH1S(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
: TH1(name,title,nbins,xlow,xup)
{
   // Create a 1-Dim histogram with fix bins of type short
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayS::Set(fNcells);

   if (xlow >= xup) SetBuffer(fgBufferSize);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1S::TH1S(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
: TH1(name,title,nbins,xbins)
{
   // Create a 1-Dim histogram with variable bins of type short
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayS::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1S::TH1S(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
: TH1(name,title,nbins,xbins)
{
   // Create a 1-Dim histogram with variable bins of type short
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayS::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


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


//______________________________________________________________________________
TH1S::TH1S(const TH1S &h1s) : TH1(), TArrayS()
{
   // Copy constructor.

   ((TH1S&)h1s).Copy(*this);
}


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

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


//______________________________________________________________________________
void TH1S::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 TH1S::Copy(TObject &newth1) const
{
   // Copy this to newth1

   TH1::Copy(newth1);
}


//______________________________________________________________________________
void TH1S::Reset(Option_t *option)
{
   // Reset.

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


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

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


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

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


//______________________________________________________________________________
TH1S operator*(Double_t c1, const TH1S &h1)
{
   // Operator *

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


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

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


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

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


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

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


//______________________________________________________________________________
TH1S operator/(const TH1S &h1, const TH1S &h2)
{
   // Operator /

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


//______________________________________________________________________________
//                     TH1I methods
// TH1I : histograms with one int per channel.    Maximum bin content = 2147483647
//______________________________________________________________________________

ClassImp(TH1I)


//______________________________________________________________________________
TH1I::TH1I(): TH1(), TArrayI()
{
   // Constructor.

   fDimension = 1;
   SetBinsLength(3);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1I::TH1I(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
: TH1(name,title,nbins,xlow,xup)
{
   // Create a 1-Dim histogram with fix bins of type integer
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayI::Set(fNcells);

   if (xlow >= xup) SetBuffer(fgBufferSize);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1I::TH1I(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
: TH1(name,title,nbins,xbins)
{
   // Create a 1-Dim histogram with variable bins of type integer
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayI::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1I::TH1I(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
: TH1(name,title,nbins,xbins)
{
   // Create a 1-Dim histogram with variable bins of type integer
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayI::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


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


//______________________________________________________________________________
TH1I::TH1I(const TH1I &h1i) : TH1(), TArrayI()
{
   // Copy constructor.

   ((TH1I&)h1i).Copy(*this);
}


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

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


//______________________________________________________________________________
void TH1I::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 TH1I::Copy(TObject &newth1) const
{
   // Copy this to newth1

   TH1::Copy(newth1);
}


//______________________________________________________________________________
void TH1I::Reset(Option_t *option)
{
   // Reset.

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


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

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


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

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



//______________________________________________________________________________
TH1I operator*(Double_t c1, const TH1I &h1)
{
   // Operator *

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


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

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


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

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


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

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


//______________________________________________________________________________
TH1I operator/(const TH1I &h1, const TH1I &h2)
{
   // Operator /

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


//______________________________________________________________________________
//                     TH1F methods
// TH1F : histograms with one float per channel.  Maximum precision 7 digits
//______________________________________________________________________________

ClassImp(TH1F)


//______________________________________________________________________________
TH1F::TH1F(): TH1(), TArrayF()
{
   // Constructor.

   fDimension = 1;
   SetBinsLength(3);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1F::TH1F(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
: TH1(name,title,nbins,xlow,xup)
{
   // Create a 1-Dim histogram with fix bins of type float
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayF::Set(fNcells);

   if (xlow >= xup) SetBuffer(fgBufferSize);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1F::TH1F(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
: TH1(name,title,nbins,xbins)
{
   // Create a 1-Dim histogram with variable bins of type float
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayF::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1F::TH1F(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
: TH1(name,title,nbins,xbins)
{
   // Create a 1-Dim histogram with variable bins of type float
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayF::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1F::TH1F(const TVectorF &v)
: TH1("TVectorF","",v.GetNrows(),0,v.GetNrows())
{
   // Create a histogram from a TVectorF
   // by default the histogram name is "TVectorF" and title = ""

   TArrayF::Set(fNcells);
   fDimension = 1;
   Int_t ivlow  = v.GetLwb();
   for (Int_t i=0;i<fNcells-2;i++) {
      SetBinContent(i+1,v(i+ivlow));
   }
   TArrayF::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1F::TH1F(const TH1F &h) : TH1(), TArrayF()
{
   // Copy Constructor.

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


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


//______________________________________________________________________________
void TH1F::Copy(TObject &newth1) const
{
   // Copy this to newth1.

   TH1::Copy(newth1);
}


//______________________________________________________________________________
void TH1F::Reset(Option_t *option)
{
   // Reset.

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


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

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


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

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


//______________________________________________________________________________
TH1F operator*(Double_t c1, const TH1F &h1)
{
   // Operator *

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


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

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


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

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


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

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


//______________________________________________________________________________
TH1F operator/(const TH1F &h1, const TH1F &h2)
{
   // Operator /

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



//______________________________________________________________________________
//                     TH1D methods
// TH1D : histograms with one double per channel. Maximum precision 14 digits
//______________________________________________________________________________

ClassImp(TH1D)


//______________________________________________________________________________
TH1D::TH1D(): TH1(), TArrayD()
{
   // Constructor.

   fDimension = 1;
   SetBinsLength(3);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1D::TH1D(const char *name,const char *title,Int_t nbins,Double_t xlow,Double_t xup)
: TH1(name,title,nbins,xlow,xup)
{
   // Create a 1-Dim histogram with fix bins of type double
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayD::Set(fNcells);

   if (xlow >= xup) SetBuffer(fgBufferSize);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1D::TH1D(const char *name,const char *title,Int_t nbins,const Float_t *xbins)
: TH1(name,title,nbins,xbins)
{
   // Create a 1-Dim histogram with variable bins of type double
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayD::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1D::TH1D(const char *name,const char *title,Int_t nbins,const Double_t *xbins)
: TH1(name,title,nbins,xbins)
{
   // Create a 1-Dim histogram with variable bins of type double
   // (see TH1::TH1 for explanation of parameters)

   fDimension = 1;
   TArrayD::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


//______________________________________________________________________________
TH1D::TH1D(const TVectorD &v)
: TH1("TVectorD","",v.GetNrows(),0,v.GetNrows())
{
   // Create a histogram from a TVectorD
   // by default the histogram name is "TVectorD" and title = ""

   TArrayD::Set(fNcells);
   fDimension = 1;
   Int_t ivlow  = v.GetLwb();
   for (Int_t i=0;i<fNcells-2;i++) {
      SetBinContent(i+1,v(i+ivlow));
   }
   TArrayD::Set(fNcells);
   if (fgDefaultSumw2) Sumw2();
}


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


//______________________________________________________________________________
TH1D::TH1D(const TH1D &h1d) : TH1(), TArrayD()
{
   // Constructor.

   ((TH1D&)h1d).Copy(*this);
}


//______________________________________________________________________________
void TH1D::Copy(TObject &newth1) const
{
   // Copy this to newth1

   TH1::Copy(newth1);
}


//______________________________________________________________________________
void TH1D::Reset(Option_t *option)
{
   // Reset.

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


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

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


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

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


//______________________________________________________________________________
TH1D operator*(Double_t c1, const TH1D &h1)
{
   // Operator *

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


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

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


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

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


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

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


//______________________________________________________________________________
TH1D operator/(const TH1D &h1, const TH1D &h2)
{
   // Operator /

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


//______________________________________________________________________________
TH1 *R__H(Int_t hid)
{
   //return pointer to histogram with name
   //   hid if id >=0
   //   h_id if id <0

   TString hname;
   if(hid >= 0) hname.Form("h%d",hid);
   else         hname.Form("h_%d",hid);
   return (TH1*)gDirectory->Get(hname);
}


//______________________________________________________________________________
TH1 *R__H(const char * hname)
{
   //return pointer to histogram with name hname

   return (TH1*)gDirectory->Get(hname);
}
 TH1.cxx:1
 TH1.cxx:2
 TH1.cxx:3
 TH1.cxx:4
 TH1.cxx:5
 TH1.cxx:6
 TH1.cxx:7
 TH1.cxx:8
 TH1.cxx:9
 TH1.cxx:10
 TH1.cxx:11
 TH1.cxx:12
 TH1.cxx:13
 TH1.cxx:14
 TH1.cxx:15
 TH1.cxx:16
 TH1.cxx:17
 TH1.cxx:18
 TH1.cxx:19
 TH1.cxx:20
 TH1.cxx:21
 TH1.cxx:22
 TH1.cxx:23
 TH1.cxx:24
 TH1.cxx:25
 TH1.cxx:26
 TH1.cxx:27
 TH1.cxx:28
 TH1.cxx:29
 TH1.cxx:30
 TH1.cxx:31
 TH1.cxx:32
 TH1.cxx:33
 TH1.cxx:34
 TH1.cxx:35
 TH1.cxx:36
 TH1.cxx:37
 TH1.cxx:38
 TH1.cxx:39
 TH1.cxx:40
 TH1.cxx:41
 TH1.cxx:42
 TH1.cxx:43
 TH1.cxx:44
 TH1.cxx:45
 TH1.cxx:46
 TH1.cxx:47
 TH1.cxx:48
 TH1.cxx:49
 TH1.cxx:50
 TH1.cxx:51
 TH1.cxx:52
 TH1.cxx:53
 TH1.cxx:54
 TH1.cxx:55
 TH1.cxx:56
 TH1.cxx:57
 TH1.cxx:58
 TH1.cxx:59
 TH1.cxx:60
 TH1.cxx:61
 TH1.cxx:62
 TH1.cxx:63
 TH1.cxx:64
 TH1.cxx:65
 TH1.cxx:66
 TH1.cxx:67
 TH1.cxx:68
 TH1.cxx:69
 TH1.cxx:70
 TH1.cxx:71
 TH1.cxx:72
 TH1.cxx:73
 TH1.cxx:74
 TH1.cxx:75
 TH1.cxx:76
 TH1.cxx:77
 TH1.cxx:78
 TH1.cxx:79
 TH1.cxx:80
 TH1.cxx:81
 TH1.cxx:82
 TH1.cxx:83
 TH1.cxx:84
 TH1.cxx:85
 TH1.cxx:86
 TH1.cxx:87
 TH1.cxx:88
 TH1.cxx:89
 TH1.cxx:90
 TH1.cxx:91
 TH1.cxx:92
 TH1.cxx:93
 TH1.cxx:94
 TH1.cxx:95
 TH1.cxx:96
 TH1.cxx:97
 TH1.cxx:98
 TH1.cxx:99
 TH1.cxx:100
 TH1.cxx:101
 TH1.cxx:102
 TH1.cxx:103
 TH1.cxx:104
 TH1.cxx:105
 TH1.cxx:106
 TH1.cxx:107
 TH1.cxx:108
 TH1.cxx:109
 TH1.cxx:110
 TH1.cxx:111
 TH1.cxx:112
 TH1.cxx:113
 TH1.cxx:114
 TH1.cxx:115
 TH1.cxx:116
 TH1.cxx:117
 TH1.cxx:118
 TH1.cxx:119
 TH1.cxx:120
 TH1.cxx:121
 TH1.cxx:122
 TH1.cxx:123
 TH1.cxx:124
 TH1.cxx:125
 TH1.cxx:126
 TH1.cxx:127
 TH1.cxx:128
 TH1.cxx:129
 TH1.cxx:130
 TH1.cxx:131
 TH1.cxx:132
 TH1.cxx:133
 TH1.cxx:134
 TH1.cxx:135
 TH1.cxx:136
 TH1.cxx:137
 TH1.cxx:138
 TH1.cxx:139
 TH1.cxx:140
 TH1.cxx:141
 TH1.cxx:142
 TH1.cxx:143
 TH1.cxx:144
 TH1.cxx:145
 TH1.cxx:146
 TH1.cxx:147
 TH1.cxx:148
 TH1.cxx:149
 TH1.cxx:150
 TH1.cxx:151
 TH1.cxx:152
 TH1.cxx:153
 TH1.cxx:154
 TH1.cxx:155
 TH1.cxx:156
 TH1.cxx:157
 TH1.cxx:158
 TH1.cxx:159
 TH1.cxx:160
 TH1.cxx:161
 TH1.cxx:162
 TH1.cxx:163
 TH1.cxx:164
 TH1.cxx:165
 TH1.cxx:166
 TH1.cxx:167
 TH1.cxx:168
 TH1.cxx:169
 TH1.cxx:170
 TH1.cxx:171
 TH1.cxx:172
 TH1.cxx:173
 TH1.cxx:174
 TH1.cxx:175
 TH1.cxx:176
 TH1.cxx:177
 TH1.cxx:178
 TH1.cxx:179
 TH1.cxx:180
 TH1.cxx:181
 TH1.cxx:182
 TH1.cxx:183
 TH1.cxx:184
 TH1.cxx:185
 TH1.cxx:186
 TH1.cxx:187
 TH1.cxx:188
 TH1.cxx:189
 TH1.cxx:190
 TH1.cxx:191
 TH1.cxx:192
 TH1.cxx:193
 TH1.cxx:194
 TH1.cxx:195
 TH1.cxx:196
 TH1.cxx:197
 TH1.cxx:198
 TH1.cxx:199
 TH1.cxx:200
 TH1.cxx:201
 TH1.cxx:202
 TH1.cxx:203
 TH1.cxx:204
 TH1.cxx:205
 TH1.cxx:206
 TH1.cxx:207
 TH1.cxx:208
 TH1.cxx:209
 TH1.cxx:210
 TH1.cxx:211
 TH1.cxx:212
 TH1.cxx:213
 TH1.cxx:214
 TH1.cxx:215
 TH1.cxx:216
 TH1.cxx:217
 TH1.cxx:218
 TH1.cxx:219
 TH1.cxx:220
 TH1.cxx:221
 TH1.cxx:222
 TH1.cxx:223
 TH1.cxx:224
 TH1.cxx:225
 TH1.cxx:226
 TH1.cxx:227
 TH1.cxx:228
 TH1.cxx:229
 TH1.cxx:230
 TH1.cxx:231
 TH1.cxx:232
 TH1.cxx:233
 TH1.cxx:234
 TH1.cxx:235
 TH1.cxx:236
 TH1.cxx:237
 TH1.cxx:238
 TH1.cxx:239
 TH1.cxx:240
 TH1.cxx:241
 TH1.cxx:242
 TH1.cxx:243
 TH1.cxx:244
 TH1.cxx:245
 TH1.cxx:246
 TH1.cxx:247
 TH1.cxx:248
 TH1.cxx:249
 TH1.cxx:250
 TH1.cxx:251
 TH1.cxx:252
 TH1.cxx:253
 TH1.cxx:254
 TH1.cxx:255
 TH1.cxx:256
 TH1.cxx:257
 TH1.cxx:258
 TH1.cxx:259
 TH1.cxx:260
 TH1.cxx:261
 TH1.cxx:262
 TH1.cxx:263
 TH1.cxx:264
 TH1.cxx:265
 TH1.cxx:266
 TH1.cxx:267
 TH1.cxx:268
 TH1.cxx:269
 TH1.cxx:270
 TH1.cxx:271
 TH1.cxx:272
 TH1.cxx:273
 TH1.cxx:274
 TH1.cxx:275
 TH1.cxx:276
 TH1.cxx:277
 TH1.cxx:278
 TH1.cxx:279
 TH1.cxx:280
 TH1.cxx:281
 TH1.cxx:282
 TH1.cxx:283
 TH1.cxx:284
 TH1.cxx:285
 TH1.cxx:286
 TH1.cxx:287
 TH1.cxx:288
 TH1.cxx:289
 TH1.cxx:290
 TH1.cxx:291
 TH1.cxx:292
 TH1.cxx:293
 TH1.cxx:294
 TH1.cxx:295
 TH1.cxx:296
 TH1.cxx:297
 TH1.cxx:298
 TH1.cxx:299
 TH1.cxx:300
 TH1.cxx:301
 TH1.cxx:302
 TH1.cxx:303
 TH1.cxx:304
 TH1.cxx:305
 TH1.cxx:306
 TH1.cxx:307
 TH1.cxx:308
 TH1.cxx:309
 TH1.cxx:310
 TH1.cxx:311
 TH1.cxx:312
 TH1.cxx:313
 TH1.cxx:314
 TH1.cxx:315
 TH1.cxx:316
 TH1.cxx:317
 TH1.cxx:318
 TH1.cxx:319
 TH1.cxx:320
 TH1.cxx:321
 TH1.cxx:322
 TH1.cxx:323
 TH1.cxx:324
 TH1.cxx:325
 TH1.cxx:326
 TH1.cxx:327
 TH1.cxx:328
 TH1.cxx:329
 TH1.cxx:330
 TH1.cxx:331
 TH1.cxx:332
 TH1.cxx:333
 TH1.cxx:334
 TH1.cxx:335
 TH1.cxx:336
 TH1.cxx:337
 TH1.cxx:338
 TH1.cxx:339
 TH1.cxx:340
 TH1.cxx:341
 TH1.cxx:342
 TH1.cxx:343
 TH1.cxx:344
 TH1.cxx:345
 TH1.cxx:346
 TH1.cxx:347
 TH1.cxx:348
 TH1.cxx:349
 TH1.cxx:350
 TH1.cxx:351
 TH1.cxx:352
 TH1.cxx:353
 TH1.cxx:354
 TH1.cxx:355
 TH1.cxx:356
 TH1.cxx:357
 TH1.cxx:358
 TH1.cxx:359
 TH1.cxx:360
 TH1.cxx:361
 TH1.cxx:362
 TH1.cxx:363
 TH1.cxx:364
 TH1.cxx:365
 TH1.cxx:366
 TH1.cxx:367
 TH1.cxx:368
 TH1.cxx:369
 TH1.cxx:370
 TH1.cxx:371
 TH1.cxx:372
 TH1.cxx:373
 TH1.cxx:374
 TH1.cxx:375
 TH1.cxx:376
 TH1.cxx:377
 TH1.cxx:378
 TH1.cxx:379
 TH1.cxx:380
 TH1.cxx:381
 TH1.cxx:382
 TH1.cxx:383
 TH1.cxx:384
 TH1.cxx:385
 TH1.cxx:386
 TH1.cxx:387
 TH1.cxx:388
 TH1.cxx:389
 TH1.cxx:390
 TH1.cxx:391
 TH1.cxx:392
 TH1.cxx:393
 TH1.cxx:394
 TH1.cxx:395
 TH1.cxx:396
 TH1.cxx:397
 TH1.cxx:398
 TH1.cxx:399
 TH1.cxx:400
 TH1.cxx:401
 TH1.cxx:402
 TH1.cxx:403
 TH1.cxx:404
 TH1.cxx:405
 TH1.cxx:406
 TH1.cxx:407
 TH1.cxx:408
 TH1.cxx:409
 TH1.cxx:410
 TH1.cxx:411
 TH1.cxx:412
 TH1.cxx:413
 TH1.cxx:414
 TH1.cxx:415
 TH1.cxx:416
 TH1.cxx:417
 TH1.cxx:418
 TH1.cxx:419
 TH1.cxx:420
 TH1.cxx:421
 TH1.cxx:422
 TH1.cxx:423
 TH1.cxx:424
 TH1.cxx:425
 TH1.cxx:426
 TH1.cxx:427
 TH1.cxx:428
 TH1.cxx:429
 TH1.cxx:430
 TH1.cxx:431
 TH1.cxx:432
 TH1.cxx:433
 TH1.cxx:434
 TH1.cxx:435
 TH1.cxx:436
 TH1.cxx:437
 TH1.cxx:438
 TH1.cxx:439
 TH1.cxx:440
 TH1.cxx:441
 TH1.cxx:442
 TH1.cxx:443
 TH1.cxx:444
 TH1.cxx:445
 TH1.cxx:446
 TH1.cxx:447
 TH1.cxx:448
 TH1.cxx:449
 TH1.cxx:450
 TH1.cxx:451
 TH1.cxx:452
 TH1.cxx:453
 TH1.cxx:454
 TH1.cxx:455
 TH1.cxx:456
 TH1.cxx:457
 TH1.cxx:458
 TH1.cxx:459
 TH1.cxx:460
 TH1.cxx:461
 TH1.cxx:462
 TH1.cxx:463
 TH1.cxx:464
 TH1.cxx:465
 TH1.cxx:466
 TH1.cxx:467
 TH1.cxx:468
 TH1.cxx:469
 TH1.cxx:470
 TH1.cxx:471
 TH1.cxx:472
 TH1.cxx:473
 TH1.cxx:474
 TH1.cxx:475
 TH1.cxx:476
 TH1.cxx:477
 TH1.cxx:478
 TH1.cxx:479
 TH1.cxx:480
 TH1.cxx:481
 TH1.cxx:482
 TH1.cxx:483
 TH1.cxx:484
 TH1.cxx:485
 TH1.cxx:486
 TH1.cxx:487
 TH1.cxx:488
 TH1.cxx:489
 TH1.cxx:490
 TH1.cxx:491
 TH1.cxx:492
 TH1.cxx:493
 TH1.cxx:494
 TH1.cxx:495
 TH1.cxx:496
 TH1.cxx:497
 TH1.cxx:498
 TH1.cxx:499
 TH1.cxx:500
 TH1.cxx:501
 TH1.cxx:502
 TH1.cxx:503
 TH1.cxx:504
 TH1.cxx:505
 TH1.cxx:506
 TH1.cxx:507
 TH1.cxx:508
 TH1.cxx:509
 TH1.cxx:510
 TH1.cxx:511
 TH1.cxx:512
 TH1.cxx:513
 TH1.cxx:514
 TH1.cxx:515
 TH1.cxx:516
 TH1.cxx:517
 TH1.cxx:518
 TH1.cxx:519
 TH1.cxx:520
 TH1.cxx:521
 TH1.cxx:522
 TH1.cxx:523
 TH1.cxx:524
 TH1.cxx:525
 TH1.cxx:526
 TH1.cxx:527
 TH1.cxx:528
 TH1.cxx:529
 TH1.cxx:530
 TH1.cxx:531
 TH1.cxx:532
 TH1.cxx:533
 TH1.cxx:534
 TH1.cxx:535
 TH1.cxx:536
 TH1.cxx:537
 TH1.cxx:538
 TH1.cxx:539
 TH1.cxx:540
 TH1.cxx:541
 TH1.cxx:542
 TH1.cxx:543
 TH1.cxx:544
 TH1.cxx:545
 TH1.cxx:546
 TH1.cxx:547
 TH1.cxx:548
 TH1.cxx:549
 TH1.cxx:550
 TH1.cxx:551
 TH1.cxx:552
 TH1.cxx:553
 TH1.cxx:554
 TH1.cxx:555
 TH1.cxx:556
 TH1.cxx:557
 TH1.cxx:558
 TH1.cxx:559
 TH1.cxx:560
 TH1.cxx:561
 TH1.cxx:562
 TH1.cxx:563
 TH1.cxx:564
 TH1.cxx:565
 TH1.cxx:566
 TH1.cxx:567
 TH1.cxx:568
 TH1.cxx:569
 TH1.cxx:570
 TH1.cxx:571
 TH1.cxx:572
 TH1.cxx:573
 TH1.cxx:574
 TH1.cxx:575
 TH1.cxx:576
 TH1.cxx:577
 TH1.cxx:578
 TH1.cxx:579
 TH1.cxx:580
 TH1.cxx:581
 TH1.cxx:582
 TH1.cxx:583
 TH1.cxx:584
 TH1.cxx:585
 TH1.cxx:586
 TH1.cxx:587
 TH1.cxx:588
 TH1.cxx:589
 TH1.cxx:590
 TH1.cxx:591
 TH1.cxx:592
 TH1.cxx:593
 TH1.cxx:594
 TH1.cxx:595
 TH1.cxx:596
 TH1.cxx:597
 TH1.cxx:598
 TH1.cxx:599
 TH1.cxx:600
 TH1.cxx:601
 TH1.cxx:602
 TH1.cxx:603
 TH1.cxx:604
 TH1.cxx:605
 TH1.cxx:606
 TH1.cxx:607
 TH1.cxx:608
 TH1.cxx:609
 TH1.cxx:610
 TH1.cxx:611
 TH1.cxx:612
 TH1.cxx:613
 TH1.cxx:614
 TH1.cxx:615
 TH1.cxx:616
 TH1.cxx:617
 TH1.cxx:618
 TH1.cxx:619
 TH1.cxx:620
 TH1.cxx:621
 TH1.cxx:622
 TH1.cxx:623
 TH1.cxx:624
 TH1.cxx:625
 TH1.cxx:626
 TH1.cxx:627
 TH1.cxx:628
 TH1.cxx:629
 TH1.cxx:630
 TH1.cxx:631
 TH1.cxx:632
 TH1.cxx:633
 TH1.cxx:634
 TH1.cxx:635
 TH1.cxx:636
 TH1.cxx:637
 TH1.cxx:638
 TH1.cxx:639
 TH1.cxx:640
 TH1.cxx:641
 TH1.cxx:642
 TH1.cxx:643
 TH1.cxx:644
 TH1.cxx:645
 TH1.cxx:646
 TH1.cxx:647
 TH1.cxx:648
 TH1.cxx:649
 TH1.cxx:650
 TH1.cxx:651
 TH1.cxx:652
 TH1.cxx:653
 TH1.cxx:654
 TH1.cxx:655
 TH1.cxx:656
 TH1.cxx:657
 TH1.cxx:658
 TH1.cxx:659
 TH1.cxx:660
 TH1.cxx:661
 TH1.cxx:662
 TH1.cxx:663
 TH1.cxx:664
 TH1.cxx:665
 TH1.cxx:666
 TH1.cxx:667
 TH1.cxx:668
 TH1.cxx:669
 TH1.cxx:670
 TH1.cxx:671
 TH1.cxx:672
 TH1.cxx:673
 TH1.cxx:674
 TH1.cxx:675
 TH1.cxx:676
 TH1.cxx:677
 TH1.cxx:678
 TH1.cxx:679
 TH1.cxx:680
 TH1.cxx:681
 TH1.cxx:682
 TH1.cxx:683
 TH1.cxx:684
 TH1.cxx:685
 TH1.cxx:686
 TH1.cxx:687
 TH1.cxx:688
 TH1.cxx:689
 TH1.cxx:690
 TH1.cxx:691
 TH1.cxx:692
 TH1.cxx:693
 TH1.cxx:694
 TH1.cxx:695
 TH1.cxx:696
 TH1.cxx:697
 TH1.cxx:698
 TH1.cxx:699
 TH1.cxx:700
 TH1.cxx:701
 TH1.cxx:702
 TH1.cxx:703
 TH1.cxx:704
 TH1.cxx:705
 TH1.cxx:706
 TH1.cxx:707
 TH1.cxx:708
 TH1.cxx:709
 TH1.cxx:710
 TH1.cxx:711
 TH1.cxx:712
 TH1.cxx:713
 TH1.cxx:714
 TH1.cxx:715
 TH1.cxx:716
 TH1.cxx:717
 TH1.cxx:718
 TH1.cxx:719
 TH1.cxx:720
 TH1.cxx:721
 TH1.cxx:722
 TH1.cxx:723
 TH1.cxx:724
 TH1.cxx:725
 TH1.cxx:726
 TH1.cxx:727
 TH1.cxx:728
 TH1.cxx:729
 TH1.cxx:730
 TH1.cxx:731
 TH1.cxx:732
 TH1.cxx:733
 TH1.cxx:734
 TH1.cxx:735
 TH1.cxx:736
 TH1.cxx:737
 TH1.cxx:738
 TH1.cxx:739
 TH1.cxx:740
 TH1.cxx:741
 TH1.cxx:742
 TH1.cxx:743
 TH1.cxx:744
 TH1.cxx:745
 TH1.cxx:746
 TH1.cxx:747
 TH1.cxx:748
 TH1.cxx:749
 TH1.cxx:750
 TH1.cxx:751
 TH1.cxx:752
 TH1.cxx:753
 TH1.cxx:754
 TH1.cxx:755
 TH1.cxx:756
 TH1.cxx:757
 TH1.cxx:758
 TH1.cxx:759
 TH1.cxx:760
 TH1.cxx:761
 TH1.cxx:762
 TH1.cxx:763
 TH1.cxx:764
 TH1.cxx:765
 TH1.cxx:766
 TH1.cxx:767
 TH1.cxx:768
 TH1.cxx:769
 TH1.cxx:770
 TH1.cxx:771
 TH1.cxx:772
 TH1.cxx:773
 TH1.cxx:774
 TH1.cxx:775
 TH1.cxx:776
 TH1.cxx:777
 TH1.cxx:778
 TH1.cxx:779
 TH1.cxx:780
 TH1.cxx:781
 TH1.cxx:782
 TH1.cxx:783
 TH1.cxx:784
 TH1.cxx:785
 TH1.cxx:786
 TH1.cxx:787
 TH1.cxx:788
 TH1.cxx:789
 TH1.cxx:790
 TH1.cxx:791
 TH1.cxx:792
 TH1.cxx:793
 TH1.cxx:794
 TH1.cxx:795
 TH1.cxx:796
 TH1.cxx:797
 TH1.cxx:798
 TH1.cxx:799
 TH1.cxx:800
 TH1.cxx:801
 TH1.cxx:802
 TH1.cxx:803
 TH1.cxx:804
 TH1.cxx:805
 TH1.cxx:806
 TH1.cxx:807
 TH1.cxx:808
 TH1.cxx:809
 TH1.cxx:810
 TH1.cxx:811
 TH1.cxx:812
 TH1.cxx:813
 TH1.cxx:814
 TH1.cxx:815
 TH1.cxx:816
 TH1.cxx:817
 TH1.cxx:818
 TH1.cxx:819
 TH1.cxx:820
 TH1.cxx:821
 TH1.cxx:822
 TH1.cxx:823
 TH1.cxx:824
 TH1.cxx:825
 TH1.cxx:826
 TH1.cxx:827
 TH1.cxx:828
 TH1.cxx:829
 TH1.cxx:830
 TH1.cxx:831
 TH1.cxx:832
 TH1.cxx:833
 TH1.cxx:834
 TH1.cxx:835
 TH1.cxx:836
 TH1.cxx:837
 TH1.cxx:838
 TH1.cxx:839
 TH1.cxx:840
 TH1.cxx:841
 TH1.cxx:842
 TH1.cxx:843
 TH1.cxx:844
 TH1.cxx:845
 TH1.cxx:846
 TH1.cxx:847
 TH1.cxx:848
 TH1.cxx:849
 TH1.cxx:850
 TH1.cxx:851
 TH1.cxx:852
 TH1.cxx:853
 TH1.cxx:854
 TH1.cxx:855
 TH1.cxx:856
 TH1.cxx:857
 TH1.cxx:858
 TH1.cxx:859
 TH1.cxx:860
 TH1.cxx:861
 TH1.cxx:862
 TH1.cxx:863
 TH1.cxx:864
 TH1.cxx:865
 TH1.cxx:866
 TH1.cxx:867
 TH1.cxx:868
 TH1.cxx:869
 TH1.cxx:870
 TH1.cxx:871
 TH1.cxx:872
 TH1.cxx:873
 TH1.cxx:874
 TH1.cxx:875
 TH1.cxx:876
 TH1.cxx:877
 TH1.cxx:878
 TH1.cxx:879
 TH1.cxx:880
 TH1.cxx:881
 TH1.cxx:882
 TH1.cxx:883
 TH1.cxx:884
 TH1.cxx:885
 TH1.cxx:886
 TH1.cxx:887
 TH1.cxx:888
 TH1.cxx:889
 TH1.cxx:890
 TH1.cxx:891
 TH1.cxx:892
 TH1.cxx:893
 TH1.cxx:894
 TH1.cxx:895
 TH1.cxx:896
 TH1.cxx:897
 TH1.cxx:898
 TH1.cxx:899
 TH1.cxx:900
 TH1.cxx:901
 TH1.cxx:902
 TH1.cxx:903
 TH1.cxx:904
 TH1.cxx:905
 TH1.cxx:906
 TH1.cxx:907
 TH1.cxx:908
 TH1.cxx:909
 TH1.cxx:910
 TH1.cxx:911
 TH1.cxx:912
 TH1.cxx:913
 TH1.cxx:914
 TH1.cxx:915
 TH1.cxx:916
 TH1.cxx:917
 TH1.cxx:918
 TH1.cxx:919
 TH1.cxx:920
 TH1.cxx:921
 TH1.cxx:922
 TH1.cxx:923
 TH1.cxx:924
 TH1.cxx:925
 TH1.cxx:926
 TH1.cxx:927
 TH1.cxx:928
 TH1.cxx:929
 TH1.cxx:930
 TH1.cxx:931
 TH1.cxx:932
 TH1.cxx:933
 TH1.cxx:934
 TH1.cxx:935
 TH1.cxx:936
 TH1.cxx:937
 TH1.cxx:938
 TH1.cxx:939
 TH1.cxx:940
 TH1.cxx:941
 TH1.cxx:942
 TH1.cxx:943
 TH1.cxx:944
 TH1.cxx:945
 TH1.cxx:946
 TH1.cxx:947
 TH1.cxx:948
 TH1.cxx:949
 TH1.cxx:950
 TH1.cxx:951
 TH1.cxx:952
 TH1.cxx:953
 TH1.cxx:954
 TH1.cxx:955
 TH1.cxx:956
 TH1.cxx:957
 TH1.cxx:958
 TH1.cxx:959
 TH1.cxx:960
 TH1.cxx:961
 TH1.cxx:962
 TH1.cxx:963
 TH1.cxx:964
 TH1.cxx:965
 TH1.cxx:966
 TH1.cxx:967
 TH1.cxx:968
 TH1.cxx:969
 TH1.cxx:970
 TH1.cxx:971
 TH1.cxx:972
 TH1.cxx:973
 TH1.cxx:974
 TH1.cxx:975
 TH1.cxx:976
 TH1.cxx:977
 TH1.cxx:978
 TH1.cxx:979
 TH1.cxx:980
 TH1.cxx:981
 TH1.cxx:982
 TH1.cxx:983
 TH1.cxx:984
 TH1.cxx:985
 TH1.cxx:986
 TH1.cxx:987
 TH1.cxx:988
 TH1.cxx:989
 TH1.cxx:990
 TH1.cxx:991
 TH1.cxx:992
 TH1.cxx:993
 TH1.cxx:994
 TH1.cxx:995
 TH1.cxx:996
 TH1.cxx:997
 TH1.cxx:998
 TH1.cxx:999
 TH1.cxx:1000
 TH1.cxx:1001
 TH1.cxx:1002
 TH1.cxx:1003
 TH1.cxx:1004
 TH1.cxx:1005
 TH1.cxx:1006
 TH1.cxx:1007
 TH1.cxx:1008
 TH1.cxx:1009
 TH1.cxx:1010
 TH1.cxx:1011
 TH1.cxx:1012
 TH1.cxx:1013
 TH1.cxx:1014
 TH1.cxx:1015
 TH1.cxx:1016
 TH1.cxx:1017
 TH1.cxx:1018
 TH1.cxx:1019
 TH1.cxx:1020
 TH1.cxx:1021
 TH1.cxx:1022
 TH1.cxx:1023
 TH1.cxx:1024
 TH1.cxx:1025
 TH1.cxx:1026
 TH1.cxx:1027
 TH1.cxx:1028
 TH1.cxx:1029
 TH1.cxx:1030
 TH1.cxx:1031
 TH1.cxx:1032
 TH1.cxx:1033
 TH1.cxx:1034
 TH1.cxx:1035
 TH1.cxx:1036
 TH1.cxx:1037
 TH1.cxx:1038
 TH1.cxx:1039
 TH1.cxx:1040
 TH1.cxx:1041
 TH1.cxx:1042
 TH1.cxx:1043
 TH1.cxx:1044
 TH1.cxx:1045
 TH1.cxx:1046
 TH1.cxx:1047
 TH1.cxx:1048
 TH1.cxx:1049
 TH1.cxx:1050
 TH1.cxx:1051
 TH1.cxx:1052
 TH1.cxx:1053
 TH1.cxx:1054
 TH1.cxx:1055
 TH1.cxx:1056
 TH1.cxx:1057
 TH1.cxx:1058
 TH1.cxx:1059
 TH1.cxx:1060
 TH1.cxx:1061
 TH1.cxx:1062
 TH1.cxx:1063
 TH1.cxx:1064
 TH1.cxx:1065
 TH1.cxx:1066
 TH1.cxx:1067
 TH1.cxx:1068
 TH1.cxx:1069
 TH1.cxx:1070
 TH1.cxx:1071
 TH1.cxx:1072
 TH1.cxx:1073
 TH1.cxx:1074
 TH1.cxx:1075
 TH1.cxx:1076
 TH1.cxx:1077
 TH1.cxx:1078
 TH1.cxx:1079
 TH1.cxx:1080
 TH1.cxx:1081
 TH1.cxx:1082
 TH1.cxx:1083
 TH1.cxx:1084
 TH1.cxx:1085
 TH1.cxx:1086
 TH1.cxx:1087
 TH1.cxx:1088
 TH1.cxx:1089
 TH1.cxx:1090
 TH1.cxx:1091
 TH1.cxx:1092
 TH1.cxx:1093
 TH1.cxx:1094
 TH1.cxx:1095
 TH1.cxx:1096
 TH1.cxx:1097
 TH1.cxx:1098
 TH1.cxx:1099
 TH1.cxx:1100
 TH1.cxx:1101
 TH1.cxx:1102
 TH1.cxx:1103
 TH1.cxx:1104
 TH1.cxx:1105
 TH1.cxx:1106
 TH1.cxx:1107
 TH1.cxx:1108
 TH1.cxx:1109
 TH1.cxx:1110
 TH1.cxx:1111
 TH1.cxx:1112
 TH1.cxx:1113
 TH1.cxx:1114
 TH1.cxx:1115
 TH1.cxx:1116
 TH1.cxx:1117
 TH1.cxx:1118
 TH1.cxx:1119
 TH1.cxx:1120
 TH1.cxx:1121
 TH1.cxx:1122
 TH1.cxx:1123
 TH1.cxx:1124
 TH1.cxx:1125
 TH1.cxx:1126
 TH1.cxx:1127
 TH1.cxx:1128
 TH1.cxx:1129
 TH1.cxx:1130
 TH1.cxx:1131
 TH1.cxx:1132
 TH1.cxx:1133
 TH1.cxx:1134
 TH1.cxx:1135
 TH1.cxx:1136
 TH1.cxx:1137
 TH1.cxx:1138
 TH1.cxx:1139
 TH1.cxx:1140
 TH1.cxx:1141
 TH1.cxx:1142
 TH1.cxx:1143
 TH1.cxx:1144
 TH1.cxx:1145
 TH1.cxx:1146
 TH1.cxx:1147
 TH1.cxx:1148
 TH1.cxx:1149
 TH1.cxx:1150
 TH1.cxx:1151
 TH1.cxx:1152
 TH1.cxx:1153
 TH1.cxx:1154
 TH1.cxx:1155
 TH1.cxx:1156
 TH1.cxx:1157
 TH1.cxx:1158
 TH1.cxx:1159
 TH1.cxx:1160
 TH1.cxx:1161
 TH1.cxx:1162
 TH1.cxx:1163
 TH1.cxx:1164
 TH1.cxx:1165
 TH1.cxx:1166
 TH1.cxx:1167
 TH1.cxx:1168
 TH1.cxx:1169
 TH1.cxx:1170
 TH1.cxx:1171
 TH1.cxx:1172
 TH1.cxx:1173
 TH1.cxx:1174
 TH1.cxx:1175
 TH1.cxx:1176
 TH1.cxx:1177
 TH1.cxx:1178
 TH1.cxx:1179
 TH1.cxx:1180
 TH1.cxx:1181
 TH1.cxx:1182
 TH1.cxx:1183
 TH1.cxx:1184
 TH1.cxx:1185
 TH1.cxx:1186
 TH1.cxx:1187
 TH1.cxx:1188
 TH1.cxx:1189
 TH1.cxx:1190
 TH1.cxx:1191
 TH1.cxx:1192
 TH1.cxx:1193
 TH1.cxx:1194
 TH1.cxx:1195
 TH1.cxx:1196
 TH1.cxx:1197
 TH1.cxx:1198
 TH1.cxx:1199
 TH1.cxx:1200
 TH1.cxx:1201
 TH1.cxx:1202
 TH1.cxx:1203
 TH1.cxx:1204
 TH1.cxx:1205
 TH1.cxx:1206
 TH1.cxx:1207
 TH1.cxx:1208
 TH1.cxx:1209
 TH1.cxx:1210
 TH1.cxx:1211
 TH1.cxx:1212
 TH1.cxx:1213
 TH1.cxx:1214
 TH1.cxx:1215
 TH1.cxx:1216
 TH1.cxx:1217
 TH1.cxx:1218
 TH1.cxx:1219
 TH1.cxx:1220
 TH1.cxx:1221
 TH1.cxx:1222
 TH1.cxx:1223
 TH1.cxx:1224
 TH1.cxx:1225
 TH1.cxx:1226
 TH1.cxx:1227
 TH1.cxx:1228
 TH1.cxx:1229
 TH1.cxx:1230
 TH1.cxx:1231
 TH1.cxx:1232
 TH1.cxx:1233
 TH1.cxx:1234
 TH1.cxx:1235
 TH1.cxx:1236
 TH1.cxx:1237
 TH1.cxx:1238
 TH1.cxx:1239
 TH1.cxx:1240
 TH1.cxx:1241
 TH1.cxx:1242
 TH1.cxx:1243
 TH1.cxx:1244
 TH1.cxx:1245
 TH1.cxx:1246
 TH1.cxx:1247
 TH1.cxx:1248
 TH1.cxx:1249
 TH1.cxx:1250
 TH1.cxx:1251
 TH1.cxx:1252
 TH1.cxx:1253
 TH1.cxx:1254
 TH1.cxx:1255
 TH1.cxx:1256
 TH1.cxx:1257
 TH1.cxx:1258
 TH1.cxx:1259
 TH1.cxx:1260
 TH1.cxx:1261
 TH1.cxx:1262
 TH1.cxx:1263
 TH1.cxx:1264
 TH1.cxx:1265
 TH1.cxx:1266
 TH1.cxx:1267
 TH1.cxx:1268
 TH1.cxx:1269
 TH1.cxx:1270
 TH1.cxx:1271
 TH1.cxx:1272
 TH1.cxx:1273
 TH1.cxx:1274
 TH1.cxx:1275
 TH1.cxx:1276
 TH1.cxx:1277
 TH1.cxx:1278
 TH1.cxx:1279
 TH1.cxx:1280
 TH1.cxx:1281
 TH1.cxx:1282
 TH1.cxx:1283
 TH1.cxx:1284
 TH1.cxx:1285
 TH1.cxx:1286
 TH1.cxx:1287
 TH1.cxx:1288
 TH1.cxx:1289
 TH1.cxx:1290
 TH1.cxx:1291
 TH1.cxx:1292
 TH1.cxx:1293
 TH1.cxx:1294
 TH1.cxx:1295
 TH1.cxx:1296
 TH1.cxx:1297
 TH1.cxx:1298
 TH1.cxx:1299
 TH1.cxx:1300
 TH1.cxx:1301
 TH1.cxx:1302
 TH1.cxx:1303
 TH1.cxx:1304
 TH1.cxx:1305
 TH1.cxx:1306
 TH1.cxx:1307
 TH1.cxx:1308
 TH1.cxx:1309
 TH1.cxx:1310
 TH1.cxx:1311
 TH1.cxx:1312
 TH1.cxx:1313
 TH1.cxx:1314
 TH1.cxx:1315
 TH1.cxx:1316
 TH1.cxx:1317
 TH1.cxx:1318
 TH1.cxx:1319
 TH1.cxx:1320
 TH1.cxx:1321
 TH1.cxx:1322
 TH1.cxx:1323
 TH1.cxx:1324
 TH1.cxx:1325
 TH1.cxx:1326
 TH1.cxx:1327
 TH1.cxx:1328
 TH1.cxx:1329
 TH1.cxx:1330
 TH1.cxx:1331
 TH1.cxx:1332
 TH1.cxx:1333
 TH1.cxx:1334
 TH1.cxx:1335
 TH1.cxx:1336
 TH1.cxx:1337
 TH1.cxx:1338
 TH1.cxx:1339
 TH1.cxx:1340
 TH1.cxx:1341
 TH1.cxx:1342
 TH1.cxx:1343
 TH1.cxx:1344
 TH1.cxx:1345
 TH1.cxx:1346
 TH1.cxx:1347
 TH1.cxx:1348
 TH1.cxx:1349
 TH1.cxx:1350
 TH1.cxx:1351
 TH1.cxx:1352
 TH1.cxx:1353
 TH1.cxx:1354
 TH1.cxx:1355
 TH1.cxx:1356
 TH1.cxx:1357
 TH1.cxx:1358
 TH1.cxx:1359
 TH1.cxx:1360
 TH1.cxx:1361
 TH1.cxx:1362
 TH1.cxx:1363
 TH1.cxx:1364
 TH1.cxx:1365
 TH1.cxx:1366
 TH1.cxx:1367
 TH1.cxx:1368
 TH1.cxx:1369
 TH1.cxx:1370
 TH1.cxx:1371
 TH1.cxx:1372
 TH1.cxx:1373
 TH1.cxx:1374
 TH1.cxx:1375
 TH1.cxx:1376
 TH1.cxx:1377
 TH1.cxx:1378
 TH1.cxx:1379
 TH1.cxx:1380
 TH1.cxx:1381
 TH1.cxx:1382
 TH1.cxx:1383
 TH1.cxx:1384
 TH1.cxx:1385
 TH1.cxx:1386
 TH1.cxx:1387
 TH1.cxx:1388
 TH1.cxx:1389
 TH1.cxx:1390
 TH1.cxx:1391
 TH1.cxx:1392
 TH1.cxx:1393
 TH1.cxx:1394
 TH1.cxx:1395
 TH1.cxx:1396
 TH1.cxx:1397
 TH1.cxx:1398
 TH1.cxx:1399
 TH1.cxx:1400
 TH1.cxx:1401
 TH1.cxx:1402
 TH1.cxx:1403
 TH1.cxx:1404
 TH1.cxx:1405
 TH1.cxx:1406
 TH1.cxx:1407
 TH1.cxx:1408
 TH1.cxx:1409
 TH1.cxx:1410
 TH1.cxx:1411
 TH1.cxx:1412
 TH1.cxx:1413
 TH1.cxx:1414
 TH1.cxx:1415
 TH1.cxx:1416
 TH1.cxx:1417
 TH1.cxx:1418
 TH1.cxx:1419
 TH1.cxx:1420
 TH1.cxx:1421
 TH1.cxx:1422
 TH1.cxx:1423
 TH1.cxx:1424
 TH1.cxx:1425
 TH1.cxx:1426
 TH1.cxx:1427
 TH1.cxx:1428
 TH1.cxx:1429
 TH1.cxx:1430
 TH1.cxx:1431
 TH1.cxx:1432
 TH1.cxx:1433
 TH1.cxx:1434
 TH1.cxx:1435
 TH1.cxx:1436
 TH1.cxx:1437
 TH1.cxx:1438
 TH1.cxx:1439
 TH1.cxx:1440
 TH1.cxx:1441
 TH1.cxx:1442
 TH1.cxx:1443
 TH1.cxx:1444
 TH1.cxx:1445
 TH1.cxx:1446
 TH1.cxx:1447
 TH1.cxx:1448
 TH1.cxx:1449
 TH1.cxx:1450
 TH1.cxx:1451
 TH1.cxx:1452
 TH1.cxx:1453
 TH1.cxx:1454
 TH1.cxx:1455
 TH1.cxx:1456
 TH1.cxx:1457
 TH1.cxx:1458
 TH1.cxx:1459
 TH1.cxx:1460
 TH1.cxx:1461
 TH1.cxx:1462
 TH1.cxx:1463
 TH1.cxx:1464
 TH1.cxx:1465
 TH1.cxx:1466
 TH1.cxx:1467
 TH1.cxx:1468
 TH1.cxx:1469
 TH1.cxx:1470
 TH1.cxx:1471
 TH1.cxx:1472
 TH1.cxx:1473
 TH1.cxx:1474
 TH1.cxx:1475
 TH1.cxx:1476
 TH1.cxx:1477
 TH1.cxx:1478
 TH1.cxx:1479
 TH1.cxx:1480
 TH1.cxx:1481
 TH1.cxx:1482
 TH1.cxx:1483
 TH1.cxx:1484
 TH1.cxx:1485
 TH1.cxx:1486
 TH1.cxx:1487
 TH1.cxx:1488
 TH1.cxx:1489
 TH1.cxx:1490
 TH1.cxx:1491
 TH1.cxx:1492
 TH1.cxx:1493
 TH1.cxx:1494
 TH1.cxx:1495
 TH1.cxx:1496
 TH1.cxx:1497
 TH1.cxx:1498
 TH1.cxx:1499
 TH1.cxx:1500
 TH1.cxx:1501
 TH1.cxx:1502
 TH1.cxx:1503
 TH1.cxx:1504
 TH1.cxx:1505
 TH1.cxx:1506
 TH1.cxx:1507
 TH1.cxx:1508
 TH1.cxx:1509
 TH1.cxx:1510
 TH1.cxx:1511
 TH1.cxx:1512
 TH1.cxx:1513
 TH1.cxx:1514
 TH1.cxx:1515
 TH1.cxx:1516
 TH1.cxx:1517
 TH1.cxx:1518
 TH1.cxx:1519
 TH1.cxx:1520
 TH1.cxx:1521
 TH1.cxx:1522
 TH1.cxx:1523
 TH1.cxx:1524
 TH1.cxx:1525
 TH1.cxx:1526
 TH1.cxx:1527
 TH1.cxx:1528
 TH1.cxx:1529
 TH1.cxx:1530
 TH1.cxx:1531
 TH1.cxx:1532
 TH1.cxx:1533
 TH1.cxx:1534
 TH1.cxx:1535
 TH1.cxx:1536
 TH1.cxx:1537
 TH1.cxx:1538
 TH1.cxx:1539
 TH1.cxx:1540
 TH1.cxx:1541
 TH1.cxx:1542
 TH1.cxx:1543
 TH1.cxx:1544
 TH1.cxx:1545
 TH1.cxx:1546
 TH1.cxx:1547
 TH1.cxx:1548
 TH1.cxx:1549
 TH1.cxx:1550
 TH1.cxx:1551
 TH1.cxx:1552
 TH1.cxx:1553
 TH1.cxx:1554
 TH1.cxx:1555
 TH1.cxx:1556
 TH1.cxx:1557
 TH1.cxx:1558
 TH1.cxx:1559
 TH1.cxx:1560
 TH1.cxx:1561
 TH1.cxx:1562
 TH1.cxx:1563
 TH1.cxx:1564
 TH1.cxx:1565
 TH1.cxx:1566
 TH1.cxx:1567
 TH1.cxx:1568
 TH1.cxx:1569
 TH1.cxx:1570
 TH1.cxx:1571
 TH1.cxx:1572
 TH1.cxx:1573
 TH1.cxx:1574
 TH1.cxx:1575
 TH1.cxx:1576
 TH1.cxx:1577
 TH1.cxx:1578
 TH1.cxx:1579
 TH1.cxx:1580
 TH1.cxx:1581
 TH1.cxx:1582
 TH1.cxx:1583
 TH1.cxx:1584
 TH1.cxx:1585
 TH1.cxx:1586
 TH1.cxx:1587
 TH1.cxx:1588
 TH1.cxx:1589
 TH1.cxx:1590
 TH1.cxx:1591
 TH1.cxx:1592
 TH1.cxx:1593
 TH1.cxx:1594
 TH1.cxx:1595
 TH1.cxx:1596
 TH1.cxx:1597
 TH1.cxx:1598
 TH1.cxx:1599
 TH1.cxx:1600
 TH1.cxx:1601
 TH1.cxx:1602
 TH1.cxx:1603
 TH1.cxx:1604
 TH1.cxx:1605
 TH1.cxx:1606
 TH1.cxx:1607
 TH1.cxx:1608
 TH1.cxx:1609
 TH1.cxx:1610
 TH1.cxx:1611
 TH1.cxx:1612
 TH1.cxx:1613
 TH1.cxx:1614
 TH1.cxx:1615
 TH1.cxx:1616
 TH1.cxx:1617
 TH1.cxx:1618
 TH1.cxx:1619
 TH1.cxx:1620
 TH1.cxx:1621
 TH1.cxx:1622
 TH1.cxx:1623
 TH1.cxx:1624
 TH1.cxx:1625
 TH1.cxx:1626
 TH1.cxx:1627
 TH1.cxx:1628
 TH1.cxx:1629
 TH1.cxx:1630
 TH1.cxx:1631
 TH1.cxx:1632
 TH1.cxx:1633
 TH1.cxx:1634
 TH1.cxx:1635
 TH1.cxx:1636
 TH1.cxx:1637
 TH1.cxx:1638
 TH1.cxx:1639
 TH1.cxx:1640
 TH1.cxx:1641
 TH1.cxx:1642
 TH1.cxx:1643
 TH1.cxx:1644
 TH1.cxx:1645
 TH1.cxx:1646
 TH1.cxx:1647
 TH1.cxx:1648
 TH1.cxx:1649
 TH1.cxx:1650
 TH1.cxx:1651
 TH1.cxx:1652
 TH1.cxx:1653
 TH1.cxx:1654
 TH1.cxx:1655
 TH1.cxx:1656
 TH1.cxx:1657
 TH1.cxx:1658
 TH1.cxx:1659
 TH1.cxx:1660
 TH1.cxx:1661
 TH1.cxx:1662
 TH1.cxx:1663
 TH1.cxx:1664
 TH1.cxx:1665
 TH1.cxx:1666
 TH1.cxx:1667
 TH1.cxx:1668
 TH1.cxx:1669
 TH1.cxx:1670
 TH1.cxx:1671
 TH1.cxx:1672
 TH1.cxx:1673
 TH1.cxx:1674
 TH1.cxx:1675
 TH1.cxx:1676
 TH1.cxx:1677
 TH1.cxx:1678
 TH1.cxx:1679
 TH1.cxx:1680
 TH1.cxx:1681
 TH1.cxx:1682
 TH1.cxx:1683
 TH1.cxx:1684
 TH1.cxx:1685
 TH1.cxx:1686
 TH1.cxx:1687
 TH1.cxx:1688
 TH1.cxx:1689
 TH1.cxx:1690
 TH1.cxx:1691
 TH1.cxx:1692
 TH1.cxx:1693
 TH1.cxx:1694
 TH1.cxx:1695
 TH1.cxx:1696
 TH1.cxx:1697
 TH1.cxx:1698
 TH1.cxx:1699
 TH1.cxx:1700
 TH1.cxx:1701
 TH1.cxx:1702
 TH1.cxx:1703
 TH1.cxx:1704
 TH1.cxx:1705
 TH1.cxx:1706
 TH1.cxx:1707
 TH1.cxx:1708
 TH1.cxx:1709
 TH1.cxx:1710
 TH1.cxx:1711
 TH1.cxx:1712
 TH1.cxx:1713
 TH1.cxx:1714
 TH1.cxx:1715
 TH1.cxx:1716
 TH1.cxx:1717
 TH1.cxx:1718
 TH1.cxx:1719
 TH1.cxx:1720
 TH1.cxx:1721
 TH1.cxx:1722
 TH1.cxx:1723
 TH1.cxx:1724
 TH1.cxx:1725
 TH1.cxx:1726
 TH1.cxx:1727
 TH1.cxx:1728
 TH1.cxx:1729
 TH1.cxx:1730
 TH1.cxx:1731
 TH1.cxx:1732
 TH1.cxx:1733
 TH1.cxx:1734
 TH1.cxx:1735
 TH1.cxx:1736
 TH1.cxx:1737
 TH1.cxx:1738
 TH1.cxx:1739
 TH1.cxx:1740
 TH1.cxx:1741
 TH1.cxx:1742
 TH1.cxx:1743
 TH1.cxx:1744
 TH1.cxx:1745
 TH1.cxx:1746
 TH1.cxx:1747
 TH1.cxx:1748
 TH1.cxx:1749
 TH1.cxx:1750
 TH1.cxx:1751
 TH1.cxx:1752
 TH1.cxx:1753
 TH1.cxx:1754
 TH1.cxx:1755
 TH1.cxx:1756
 TH1.cxx:1757
 TH1.cxx:1758
 TH1.cxx:1759
 TH1.cxx:1760
 TH1.cxx:1761
 TH1.cxx:1762
 TH1.cxx:1763
 TH1.cxx:1764
 TH1.cxx:1765
 TH1.cxx:1766
 TH1.cxx:1767
 TH1.cxx:1768
 TH1.cxx:1769
 TH1.cxx:1770
 TH1.cxx:1771
 TH1.cxx:1772
 TH1.cxx:1773
 TH1.cxx:1774
 TH1.cxx:1775
 TH1.cxx:1776
 TH1.cxx:1777
 TH1.cxx:1778
 TH1.cxx:1779
 TH1.cxx:1780
 TH1.cxx:1781
 TH1.cxx:1782
 TH1.cxx:1783
 TH1.cxx:1784
 TH1.cxx:1785
 TH1.cxx:1786
 TH1.cxx:1787
 TH1.cxx:1788
 TH1.cxx:1789
 TH1.cxx:1790
 TH1.cxx:1791
 TH1.cxx:1792
 TH1.cxx:1793
 TH1.cxx:1794
 TH1.cxx:1795
 TH1.cxx:1796
 TH1.cxx:1797
 TH1.cxx:1798
 TH1.cxx:1799
 TH1.cxx:1800
 TH1.cxx:1801
 TH1.cxx:1802
 TH1.cxx:1803
 TH1.cxx:1804
 TH1.cxx:1805
 TH1.cxx:1806
 TH1.cxx:1807
 TH1.cxx:1808
 TH1.cxx:1809
 TH1.cxx:1810
 TH1.cxx:1811
 TH1.cxx:1812
 TH1.cxx:1813
 TH1.cxx:1814
 TH1.cxx:1815
 TH1.cxx:1816
 TH1.cxx:1817
 TH1.cxx:1818
 TH1.cxx:1819
 TH1.cxx:1820
 TH1.cxx:1821
 TH1.cxx:1822
 TH1.cxx:1823
 TH1.cxx:1824
 TH1.cxx:1825
 TH1.cxx:1826
 TH1.cxx:1827
 TH1.cxx:1828
 TH1.cxx:1829
 TH1.cxx:1830
 TH1.cxx:1831
 TH1.cxx:1832
 TH1.cxx:1833
 TH1.cxx:1834
 TH1.cxx:1835
 TH1.cxx:1836
 TH1.cxx:1837
 TH1.cxx:1838
 TH1.cxx:1839
 TH1.cxx:1840
 TH1.cxx:1841
 TH1.cxx:1842
 TH1.cxx:1843
 TH1.cxx:1844
 TH1.cxx:1845
 TH1.cxx:1846
 TH1.cxx:1847
 TH1.cxx:1848
 TH1.cxx:1849
 TH1.cxx:1850
 TH1.cxx:1851
 TH1.cxx:1852
 TH1.cxx:1853
 TH1.cxx:1854
 TH1.cxx:1855
 TH1.cxx:1856
 TH1.cxx:1857
 TH1.cxx:1858
 TH1.cxx:1859
 TH1.cxx:1860
 TH1.cxx:1861
 TH1.cxx:1862
 TH1.cxx:1863
 TH1.cxx:1864
 TH1.cxx:1865
 TH1.cxx:1866
 TH1.cxx:1867
 TH1.cxx:1868
 TH1.cxx:1869
 TH1.cxx:1870
 TH1.cxx:1871
 TH1.cxx:1872
 TH1.cxx:1873
 TH1.cxx:1874
 TH1.cxx:1875
 TH1.cxx:1876
 TH1.cxx:1877
 TH1.cxx:1878
 TH1.cxx:1879
 TH1.cxx:1880
 TH1.cxx:1881
 TH1.cxx:1882
 TH1.cxx:1883
 TH1.cxx:1884
 TH1.cxx:1885
 TH1.cxx:1886
 TH1.cxx:1887
 TH1.cxx:1888
 TH1.cxx:1889
 TH1.cxx:1890
 TH1.cxx:1891
 TH1.cxx:1892
 TH1.cxx:1893
 TH1.cxx:1894
 TH1.cxx:1895
 TH1.cxx:1896
 TH1.cxx:1897
 TH1.cxx:1898
 TH1.cxx:1899
 TH1.cxx:1900
 TH1.cxx:1901
 TH1.cxx:1902
 TH1.cxx:1903
 TH1.cxx:1904
 TH1.cxx:1905
 TH1.cxx:1906
 TH1.cxx:1907
 TH1.cxx:1908
 TH1.cxx:1909
 TH1.cxx:1910
 TH1.cxx:1911
 TH1.cxx:1912
 TH1.cxx:1913
 TH1.cxx:1914
 TH1.cxx:1915
 TH1.cxx:1916
 TH1.cxx:1917
 TH1.cxx:1918
 TH1.cxx:1919
 TH1.cxx:1920
 TH1.cxx:1921
 TH1.cxx:1922
 TH1.cxx:1923
 TH1.cxx:1924
 TH1.cxx:1925
 TH1.cxx:1926
 TH1.cxx:1927
 TH1.cxx:1928
 TH1.cxx:1929
 TH1.cxx:1930
 TH1.cxx:1931
 TH1.cxx:1932
 TH1.cxx:1933
 TH1.cxx:1934
 TH1.cxx:1935
 TH1.cxx:1936
 TH1.cxx:1937
 TH1.cxx:1938
 TH1.cxx:1939
 TH1.cxx:1940
 TH1.cxx:1941
 TH1.cxx:1942
 TH1.cxx:1943
 TH1.cxx:1944
 TH1.cxx:1945
 TH1.cxx:1946
 TH1.cxx:1947
 TH1.cxx:1948
 TH1.cxx:1949
 TH1.cxx:1950
 TH1.cxx:1951
 TH1.cxx:1952
 TH1.cxx:1953
 TH1.cxx:1954
 TH1.cxx:1955
 TH1.cxx:1956
 TH1.cxx:1957
 TH1.cxx:1958
 TH1.cxx:1959
 TH1.cxx:1960
 TH1.cxx:1961
 TH1.cxx:1962
 TH1.cxx:1963
 TH1.cxx:1964
 TH1.cxx:1965
 TH1.cxx:1966
 TH1.cxx:1967
 TH1.cxx:1968
 TH1.cxx:1969
 TH1.cxx:1970
 TH1.cxx:1971
 TH1.cxx:1972
 TH1.cxx:1973
 TH1.cxx:1974
 TH1.cxx:1975
 TH1.cxx:1976
 TH1.cxx:1977
 TH1.cxx:1978
 TH1.cxx:1979
 TH1.cxx:1980
 TH1.cxx:1981
 TH1.cxx:1982
 TH1.cxx:1983
 TH1.cxx:1984
 TH1.cxx:1985
 TH1.cxx:1986
 TH1.cxx:1987
 TH1.cxx:1988
 TH1.cxx:1989
 TH1.cxx:1990
 TH1.cxx:1991
 TH1.cxx:1992
 TH1.cxx:1993
 TH1.cxx:1994
 TH1.cxx:1995
 TH1.cxx:1996
 TH1.cxx:1997
 TH1.cxx:1998
 TH1.cxx:1999
 TH1.cxx:2000
 TH1.cxx:2001
 TH1.cxx:2002
 TH1.cxx:2003
 TH1.cxx:2004
 TH1.cxx:2005
 TH1.cxx:2006
 TH1.cxx:2007
 TH1.cxx:2008
 TH1.cxx:2009
 TH1.cxx:2010
 TH1.cxx:2011
 TH1.cxx:2012
 TH1.cxx:2013
 TH1.cxx:2014
 TH1.cxx:2015
 TH1.cxx:2016
 TH1.cxx:2017
 TH1.cxx:2018
 TH1.cxx:2019
 TH1.cxx:2020
 TH1.cxx:2021
 TH1.cxx:2022
 TH1.cxx:2023
 TH1.cxx:2024
 TH1.cxx:2025
 TH1.cxx:2026
 TH1.cxx:2027
 TH1.cxx:2028
 TH1.cxx:2029
 TH1.cxx:2030
 TH1.cxx:2031
 TH1.cxx:2032
 TH1.cxx:2033
 TH1.cxx:2034
 TH1.cxx:2035
 TH1.cxx:2036
 TH1.cxx:2037
 TH1.cxx:2038
 TH1.cxx:2039
 TH1.cxx:2040
 TH1.cxx:2041
 TH1.cxx:2042
 TH1.cxx:2043
 TH1.cxx:2044
 TH1.cxx:2045
 TH1.cxx:2046
 TH1.cxx:2047
 TH1.cxx:2048
 TH1.cxx:2049
 TH1.cxx:2050
 TH1.cxx:2051
 TH1.cxx:2052
 TH1.cxx:2053
 TH1.cxx:2054
 TH1.cxx:2055
 TH1.cxx:2056
 TH1.cxx:2057
 TH1.cxx:2058
 TH1.cxx:2059
 TH1.cxx:2060
 TH1.cxx:2061
 TH1.cxx:2062
 TH1.cxx:2063
 TH1.cxx:2064
 TH1.cxx:2065
 TH1.cxx:2066
 TH1.cxx:2067
 TH1.cxx:2068
 TH1.cxx:2069
 TH1.cxx:2070
 TH1.cxx:2071
 TH1.cxx:2072
 TH1.cxx:2073
 TH1.cxx:2074
 TH1.cxx:2075
 TH1.cxx:2076
 TH1.cxx:2077
 TH1.cxx:2078
 TH1.cxx:2079
 TH1.cxx:2080
 TH1.cxx:2081
 TH1.cxx:2082
 TH1.cxx:2083
 TH1.cxx:2084
 TH1.cxx:2085
 TH1.cxx:2086
 TH1.cxx:2087
 TH1.cxx:2088
 TH1.cxx:2089
 TH1.cxx:2090
 TH1.cxx:2091
 TH1.cxx:2092
 TH1.cxx:2093
 TH1.cxx:2094
 TH1.cxx:2095
 TH1.cxx:2096
 TH1.cxx:2097
 TH1.cxx:2098
 TH1.cxx:2099
 TH1.cxx:2100
 TH1.cxx:2101
 TH1.cxx:2102
 TH1.cxx:2103
 TH1.cxx:2104
 TH1.cxx:2105
 TH1.cxx:2106
 TH1.cxx:2107
 TH1.cxx:2108
 TH1.cxx:2109
 TH1.cxx:2110
 TH1.cxx:2111
 TH1.cxx:2112
 TH1.cxx:2113
 TH1.cxx:2114
 TH1.cxx:2115
 TH1.cxx:2116
 TH1.cxx:2117
 TH1.cxx:2118
 TH1.cxx:2119
 TH1.cxx:2120
 TH1.cxx:2121
 TH1.cxx:2122
 TH1.cxx:2123
 TH1.cxx:2124
 TH1.cxx:2125
 TH1.cxx:2126
 TH1.cxx:2127
 TH1.cxx:2128
 TH1.cxx:2129
 TH1.cxx:2130
 TH1.cxx:2131
 TH1.cxx:2132
 TH1.cxx:2133
 TH1.cxx:2134
 TH1.cxx:2135
 TH1.cxx:2136
 TH1.cxx:2137
 TH1.cxx:2138
 TH1.cxx:2139
 TH1.cxx:2140
 TH1.cxx:2141
 TH1.cxx:2142
 TH1.cxx:2143
 TH1.cxx:2144
 TH1.cxx:2145
 TH1.cxx:2146
 TH1.cxx:2147
 TH1.cxx:2148
 TH1.cxx:2149
 TH1.cxx:2150
 TH1.cxx:2151
 TH1.cxx:2152
 TH1.cxx:2153
 TH1.cxx:2154
 TH1.cxx:2155
 TH1.cxx:2156
 TH1.cxx:2157
 TH1.cxx:2158
 TH1.cxx:2159
 TH1.cxx:2160
 TH1.cxx:2161
 TH1.cxx:2162
 TH1.cxx:2163
 TH1.cxx:2164
 TH1.cxx:2165
 TH1.cxx:2166
 TH1.cxx:2167
 TH1.cxx:2168
 TH1.cxx:2169
 TH1.cxx:2170
 TH1.cxx:2171
 TH1.cxx:2172
 TH1.cxx:2173
 TH1.cxx:2174
 TH1.cxx:2175
 TH1.cxx:2176
 TH1.cxx:2177
 TH1.cxx:2178
 TH1.cxx:2179
 TH1.cxx:2180
 TH1.cxx:2181
 TH1.cxx:2182
 TH1.cxx:2183
 TH1.cxx:2184
 TH1.cxx:2185
 TH1.cxx:2186
 TH1.cxx:2187
 TH1.cxx:2188
 TH1.cxx:2189
 TH1.cxx:2190
 TH1.cxx:2191
 TH1.cxx:2192
 TH1.cxx:2193
 TH1.cxx:2194
 TH1.cxx:2195
 TH1.cxx:2196
 TH1.cxx:2197
 TH1.cxx:2198
 TH1.cxx:2199
 TH1.cxx:2200
 TH1.cxx:2201
 TH1.cxx:2202
 TH1.cxx:2203
 TH1.cxx:2204
 TH1.cxx:2205
 TH1.cxx:2206
 TH1.cxx:2207
 TH1.cxx:2208
 TH1.cxx:2209
 TH1.cxx:2210
 TH1.cxx:2211
 TH1.cxx:2212
 TH1.cxx:2213
 TH1.cxx:2214
 TH1.cxx:2215
 TH1.cxx:2216
 TH1.cxx:2217
 TH1.cxx:2218
 TH1.cxx:2219
 TH1.cxx:2220
 TH1.cxx:2221
 TH1.cxx:2222
 TH1.cxx:2223
 TH1.cxx:2224
 TH1.cxx:2225
 TH1.cxx:2226
 TH1.cxx:2227
 TH1.cxx:2228
 TH1.cxx:2229
 TH1.cxx:2230
 TH1.cxx:2231
 TH1.cxx:2232
 TH1.cxx:2233
 TH1.cxx:2234
 TH1.cxx:2235
 TH1.cxx:2236
 TH1.cxx:2237
 TH1.cxx:2238
 TH1.cxx:2239
 TH1.cxx:2240
 TH1.cxx:2241
 TH1.cxx:2242
 TH1.cxx:2243
 TH1.cxx:2244
 TH1.cxx:2245
 TH1.cxx:2246
 TH1.cxx:2247
 TH1.cxx:2248
 TH1.cxx:2249
 TH1.cxx:2250
 TH1.cxx:2251
 TH1.cxx:2252
 TH1.cxx:2253
 TH1.cxx:2254
 TH1.cxx:2255
 TH1.cxx:2256
 TH1.cxx:2257
 TH1.cxx:2258
 TH1.cxx:2259
 TH1.cxx:2260
 TH1.cxx:2261
 TH1.cxx:2262
 TH1.cxx:2263
 TH1.cxx:2264
 TH1.cxx:2265
 TH1.cxx:2266
 TH1.cxx:2267
 TH1.cxx:2268
 TH1.cxx:2269
 TH1.cxx:2270
 TH1.cxx:2271
 TH1.cxx:2272
 TH1.cxx:2273
 TH1.cxx:2274
 TH1.cxx:2275
 TH1.cxx:2276
 TH1.cxx:2277
 TH1.cxx:2278
 TH1.cxx:2279
 TH1.cxx:2280
 TH1.cxx:2281
 TH1.cxx:2282
 TH1.cxx:2283
 TH1.cxx:2284
 TH1.cxx:2285
 TH1.cxx:2286
 TH1.cxx:2287
 TH1.cxx:2288
 TH1.cxx:2289
 TH1.cxx:2290
 TH1.cxx:2291
 TH1.cxx:2292
 TH1.cxx:2293
 TH1.cxx:2294
 TH1.cxx:2295
 TH1.cxx:2296
 TH1.cxx:2297
 TH1.cxx:2298
 TH1.cxx:2299
 TH1.cxx:2300
 TH1.cxx:2301
 TH1.cxx:2302
 TH1.cxx:2303
 TH1.cxx:2304
 TH1.cxx:2305
 TH1.cxx:2306
 TH1.cxx:2307
 TH1.cxx:2308
 TH1.cxx:2309
 TH1.cxx:2310
 TH1.cxx:2311
 TH1.cxx:2312
 TH1.cxx:2313
 TH1.cxx:2314
 TH1.cxx:2315
 TH1.cxx:2316
 TH1.cxx:2317
 TH1.cxx:2318
 TH1.cxx:2319
 TH1.cxx:2320
 TH1.cxx:2321
 TH1.cxx:2322
 TH1.cxx:2323
 TH1.cxx:2324
 TH1.cxx:2325
 TH1.cxx:2326
 TH1.cxx:2327
 TH1.cxx:2328
 TH1.cxx:2329
 TH1.cxx:2330
 TH1.cxx:2331
 TH1.cxx:2332
 TH1.cxx:2333
 TH1.cxx:2334
 TH1.cxx:2335
 TH1.cxx:2336
 TH1.cxx:2337
 TH1.cxx:2338
 TH1.cxx:2339
 TH1.cxx:2340
 TH1.cxx:2341
 TH1.cxx:2342
 TH1.cxx:2343
 TH1.cxx:2344
 TH1.cxx:2345
 TH1.cxx:2346
 TH1.cxx:2347
 TH1.cxx:2348
 TH1.cxx:2349
 TH1.cxx:2350
 TH1.cxx:2351
 TH1.cxx:2352
 TH1.cxx:2353
 TH1.cxx:2354
 TH1.cxx:2355
 TH1.cxx:2356
 TH1.cxx:2357
 TH1.cxx:2358
 TH1.cxx:2359
 TH1.cxx:2360
 TH1.cxx:2361
 TH1.cxx:2362
 TH1.cxx:2363
 TH1.cxx:2364
 TH1.cxx:2365
 TH1.cxx:2366
 TH1.cxx:2367
 TH1.cxx:2368
 TH1.cxx:2369
 TH1.cxx:2370
 TH1.cxx:2371
 TH1.cxx:2372
 TH1.cxx:2373
 TH1.cxx:2374
 TH1.cxx:2375
 TH1.cxx:2376
 TH1.cxx:2377
 TH1.cxx:2378
 TH1.cxx:2379
 TH1.cxx:2380
 TH1.cxx:2381
 TH1.cxx:2382
 TH1.cxx:2383
 TH1.cxx:2384
 TH1.cxx:2385
 TH1.cxx:2386
 TH1.cxx:2387
 TH1.cxx:2388
 TH1.cxx:2389
 TH1.cxx:2390
 TH1.cxx:2391
 TH1.cxx:2392
 TH1.cxx:2393
 TH1.cxx:2394
 TH1.cxx:2395
 TH1.cxx:2396
 TH1.cxx:2397
 TH1.cxx:2398
 TH1.cxx:2399
 TH1.cxx:2400
 TH1.cxx:2401
 TH1.cxx:2402
 TH1.cxx:2403
 TH1.cxx:2404
 TH1.cxx:2405
 TH1.cxx:2406
 TH1.cxx:2407
 TH1.cxx:2408
 TH1.cxx:2409
 TH1.cxx:2410
 TH1.cxx:2411
 TH1.cxx:2412
 TH1.cxx:2413
 TH1.cxx:2414
 TH1.cxx:2415
 TH1.cxx:2416
 TH1.cxx:2417
 TH1.cxx:2418
 TH1.cxx:2419
 TH1.cxx:2420
 TH1.cxx:2421
 TH1.cxx:2422
 TH1.cxx:2423
 TH1.cxx:2424
 TH1.cxx:2425
 TH1.cxx:2426
 TH1.cxx:2427
 TH1.cxx:2428
 TH1.cxx:2429
 TH1.cxx:2430
 TH1.cxx:2431
 TH1.cxx:2432
 TH1.cxx:2433
 TH1.cxx:2434
 TH1.cxx:2435
 TH1.cxx:2436
 TH1.cxx:2437
 TH1.cxx:2438
 TH1.cxx:2439
 TH1.cxx:2440
 TH1.cxx:2441
 TH1.cxx:2442
 TH1.cxx:2443
 TH1.cxx:2444
 TH1.cxx:2445
 TH1.cxx:2446
 TH1.cxx:2447
 TH1.cxx:2448
 TH1.cxx:2449
 TH1.cxx:2450
 TH1.cxx:2451
 TH1.cxx:2452
 TH1.cxx:2453
 TH1.cxx:2454
 TH1.cxx:2455
 TH1.cxx:2456
 TH1.cxx:2457
 TH1.cxx:2458
 TH1.cxx:2459
 TH1.cxx:2460
 TH1.cxx:2461
 TH1.cxx:2462
 TH1.cxx:2463
 TH1.cxx:2464
 TH1.cxx:2465
 TH1.cxx:2466
 TH1.cxx:2467
 TH1.cxx:2468
 TH1.cxx:2469
 TH1.cxx:2470
 TH1.cxx:2471
 TH1.cxx:2472
 TH1.cxx:2473
 TH1.cxx:2474
 TH1.cxx:2475
 TH1.cxx:2476
 TH1.cxx:2477
 TH1.cxx:2478
 TH1.cxx:2479
 TH1.cxx:2480
 TH1.cxx:2481
 TH1.cxx:2482
 TH1.cxx:2483
 TH1.cxx:2484
 TH1.cxx:2485
 TH1.cxx:2486
 TH1.cxx:2487
 TH1.cxx:2488
 TH1.cxx:2489
 TH1.cxx:2490
 TH1.cxx:2491
 TH1.cxx:2492
 TH1.cxx:2493
 TH1.cxx:2494
 TH1.cxx:2495
 TH1.cxx:2496
 TH1.cxx:2497
 TH1.cxx:2498
 TH1.cxx:2499
 TH1.cxx:2500
 TH1.cxx:2501
 TH1.cxx:2502
 TH1.cxx:2503
 TH1.cxx:2504
 TH1.cxx:2505
 TH1.cxx:2506
 TH1.cxx:2507
 TH1.cxx:2508
 TH1.cxx:2509
 TH1.cxx:2510
 TH1.cxx:2511
 TH1.cxx:2512
 TH1.cxx:2513
 TH1.cxx:2514
 TH1.cxx:2515
 TH1.cxx:2516
 TH1.cxx:2517
 TH1.cxx:2518
 TH1.cxx:2519
 TH1.cxx:2520
 TH1.cxx:2521
 TH1.cxx:2522
 TH1.cxx:2523
 TH1.cxx:2524
 TH1.cxx:2525
 TH1.cxx:2526
 TH1.cxx:2527
 TH1.cxx:2528
 TH1.cxx:2529
 TH1.cxx:2530
 TH1.cxx:2531
 TH1.cxx:2532
 TH1.cxx:2533
 TH1.cxx:2534
 TH1.cxx:2535
 TH1.cxx:2536
 TH1.cxx:2537
 TH1.cxx:2538
 TH1.cxx:2539
 TH1.cxx:2540
 TH1.cxx:2541
 TH1.cxx:2542
 TH1.cxx:2543
 TH1.cxx:2544
 TH1.cxx:2545
 TH1.cxx:2546
 TH1.cxx:2547
 TH1.cxx:2548
 TH1.cxx:2549
 TH1.cxx:2550
 TH1.cxx:2551
 TH1.cxx:2552
 TH1.cxx:2553
 TH1.cxx:2554
 TH1.cxx:2555
 TH1.cxx:2556
 TH1.cxx:2557
 TH1.cxx:2558
 TH1.cxx:2559
 TH1.cxx:2560
 TH1.cxx:2561
 TH1.cxx:2562
 TH1.cxx:2563
 TH1.cxx:2564
 TH1.cxx:2565
 TH1.cxx:2566
 TH1.cxx:2567
 TH1.cxx:2568
 TH1.cxx:2569
 TH1.cxx:2570
 TH1.cxx:2571
 TH1.cxx:2572
 TH1.cxx:2573
 TH1.cxx:2574
 TH1.cxx:2575
 TH1.cxx:2576
 TH1.cxx:2577
 TH1.cxx:2578
 TH1.cxx:2579
 TH1.cxx:2580
 TH1.cxx:2581
 TH1.cxx:2582
 TH1.cxx:2583
 TH1.cxx:2584
 TH1.cxx:2585
 TH1.cxx:2586
 TH1.cxx:2587
 TH1.cxx:2588
 TH1.cxx:2589
 TH1.cxx:2590
 TH1.cxx:2591
 TH1.cxx:2592
 TH1.cxx:2593
 TH1.cxx:2594
 TH1.cxx:2595
 TH1.cxx:2596
 TH1.cxx:2597
 TH1.cxx:2598
 TH1.cxx:2599
 TH1.cxx:2600
 TH1.cxx:2601
 TH1.cxx:2602
 TH1.cxx:2603
 TH1.cxx:2604
 TH1.cxx:2605
 TH1.cxx:2606
 TH1.cxx:2607
 TH1.cxx:2608
 TH1.cxx:2609
 TH1.cxx:2610
 TH1.cxx:2611
 TH1.cxx:2612
 TH1.cxx:2613
 TH1.cxx:2614
 TH1.cxx:2615
 TH1.cxx:2616
 TH1.cxx:2617
 TH1.cxx:2618
 TH1.cxx:2619
 TH1.cxx:2620
 TH1.cxx:2621
 TH1.cxx:2622
 TH1.cxx:2623
 TH1.cxx:2624
 TH1.cxx:2625
 TH1.cxx:2626
 TH1.cxx:2627
 TH1.cxx:2628
 TH1.cxx:2629
 TH1.cxx:2630
 TH1.cxx:2631
 TH1.cxx:2632
 TH1.cxx:2633
 TH1.cxx:2634
 TH1.cxx:2635
 TH1.cxx:2636
 TH1.cxx:2637
 TH1.cxx:2638
 TH1.cxx:2639
 TH1.cxx:2640
 TH1.cxx:2641
 TH1.cxx:2642
 TH1.cxx:2643
 TH1.cxx:2644
 TH1.cxx:2645
 TH1.cxx:2646
 TH1.cxx:2647
 TH1.cxx:2648
 TH1.cxx:2649
 TH1.cxx:2650
 TH1.cxx:2651
 TH1.cxx:2652
 TH1.cxx:2653
 TH1.cxx:2654
 TH1.cxx:2655
 TH1.cxx:2656
 TH1.cxx:2657
 TH1.cxx:2658
 TH1.cxx:2659
 TH1.cxx:2660
 TH1.cxx:2661
 TH1.cxx:2662
 TH1.cxx:2663
 TH1.cxx:2664
 TH1.cxx:2665
 TH1.cxx:2666
 TH1.cxx:2667
 TH1.cxx:2668
 TH1.cxx:2669
 TH1.cxx:2670
 TH1.cxx:2671
 TH1.cxx:2672
 TH1.cxx:2673
 TH1.cxx:2674
 TH1.cxx:2675
 TH1.cxx:2676
 TH1.cxx:2677
 TH1.cxx:2678
 TH1.cxx:2679
 TH1.cxx:2680
 TH1.cxx:2681
 TH1.cxx:2682
 TH1.cxx:2683
 TH1.cxx:2684
 TH1.cxx:2685
 TH1.cxx:2686
 TH1.cxx:2687
 TH1.cxx:2688
 TH1.cxx:2689
 TH1.cxx:2690
 TH1.cxx:2691
 TH1.cxx:2692
 TH1.cxx:2693
 TH1.cxx:2694
 TH1.cxx:2695
 TH1.cxx:2696
 TH1.cxx:2697
 TH1.cxx:2698
 TH1.cxx:2699
 TH1.cxx:2700
 TH1.cxx:2701
 TH1.cxx:2702
 TH1.cxx:2703
 TH1.cxx:2704
 TH1.cxx:2705
 TH1.cxx:2706
 TH1.cxx:2707
 TH1.cxx:2708
 TH1.cxx:2709
 TH1.cxx:2710
 TH1.cxx:2711
 TH1.cxx:2712
 TH1.cxx:2713
 TH1.cxx:2714
 TH1.cxx:2715
 TH1.cxx:2716
 TH1.cxx:2717
 TH1.cxx:2718
 TH1.cxx:2719
 TH1.cxx:2720
 TH1.cxx:2721
 TH1.cxx:2722
 TH1.cxx:2723
 TH1.cxx:2724
 TH1.cxx:2725
 TH1.cxx:2726
 TH1.cxx:2727
 TH1.cxx:2728
 TH1.cxx:2729
 TH1.cxx:2730
 TH1.cxx:2731
 TH1.cxx:2732
 TH1.cxx:2733
 TH1.cxx:2734
 TH1.cxx:2735
 TH1.cxx:2736
 TH1.cxx:2737
 TH1.cxx:2738
 TH1.cxx:2739
 TH1.cxx:2740
 TH1.cxx:2741
 TH1.cxx:2742
 TH1.cxx:2743
 TH1.cxx:2744
 TH1.cxx:2745
 TH1.cxx:2746
 TH1.cxx:2747
 TH1.cxx:2748
 TH1.cxx:2749
 TH1.cxx:2750
 TH1.cxx:2751
 TH1.cxx:2752
 TH1.cxx:2753
 TH1.cxx:2754
 TH1.cxx:2755
 TH1.cxx:2756
 TH1.cxx:2757
 TH1.cxx:2758
 TH1.cxx:2759
 TH1.cxx:2760
 TH1.cxx:2761
 TH1.cxx:2762
 TH1.cxx:2763
 TH1.cxx:2764
 TH1.cxx:2765
 TH1.cxx:2766
 TH1.cxx:2767
 TH1.cxx:2768
 TH1.cxx:2769
 TH1.cxx:2770
 TH1.cxx:2771
 TH1.cxx:2772
 TH1.cxx:2773
 TH1.cxx:2774
 TH1.cxx:2775
 TH1.cxx:2776
 TH1.cxx:2777
 TH1.cxx:2778
 TH1.cxx:2779
 TH1.cxx:2780
 TH1.cxx:2781
 TH1.cxx:2782
 TH1.cxx:2783
 TH1.cxx:2784
 TH1.cxx:2785
 TH1.cxx:2786
 TH1.cxx:2787
 TH1.cxx:2788
 TH1.cxx:2789
 TH1.cxx:2790
 TH1.cxx:2791
 TH1.cxx:2792
 TH1.cxx:2793
 TH1.cxx:2794
 TH1.cxx:2795
 TH1.cxx:2796
 TH1.cxx:2797
 TH1.cxx:2798
 TH1.cxx:2799
 TH1.cxx:2800
 TH1.cxx:2801
 TH1.cxx:2802
 TH1.cxx:2803
 TH1.cxx:2804
 TH1.cxx:2805
 TH1.cxx:2806
 TH1.cxx:2807
 TH1.cxx:2808
 TH1.cxx:2809
 TH1.cxx:2810
 TH1.cxx:2811
 TH1.cxx:2812
 TH1.cxx:2813
 TH1.cxx:2814
 TH1.cxx:2815
 TH1.cxx:2816
 TH1.cxx:2817
 TH1.cxx:2818
 TH1.cxx:2819
 TH1.cxx:2820
 TH1.cxx:2821
 TH1.cxx:2822
 TH1.cxx:2823
 TH1.cxx:2824
 TH1.cxx:2825
 TH1.cxx:2826
 TH1.cxx:2827
 TH1.cxx:2828
 TH1.cxx:2829
 TH1.cxx:2830
 TH1.cxx:2831
 TH1.cxx:2832
 TH1.cxx:2833
 TH1.cxx:2834
 TH1.cxx:2835
 TH1.cxx:2836
 TH1.cxx:2837
 TH1.cxx:2838
 TH1.cxx:2839
 TH1.cxx:2840
 TH1.cxx:2841
 TH1.cxx:2842
 TH1.cxx:2843
 TH1.cxx:2844
 TH1.cxx:2845
 TH1.cxx:2846
 TH1.cxx:2847
 TH1.cxx:2848
 TH1.cxx:2849
 TH1.cxx:2850
 TH1.cxx:2851
 TH1.cxx:2852
 TH1.cxx:2853
 TH1.cxx:2854
 TH1.cxx:2855
 TH1.cxx:2856
 TH1.cxx:2857
 TH1.cxx:2858
 TH1.cxx:2859
 TH1.cxx:2860
 TH1.cxx:2861
 TH1.cxx:2862
 TH1.cxx:2863
 TH1.cxx:2864
 TH1.cxx:2865
 TH1.cxx:2866
 TH1.cxx:2867
 TH1.cxx:2868
 TH1.cxx:2869
 TH1.cxx:2870
 TH1.cxx:2871
 TH1.cxx:2872
 TH1.cxx:2873
 TH1.cxx:2874
 TH1.cxx:2875
 TH1.cxx:2876
 TH1.cxx:2877
 TH1.cxx:2878
 TH1.cxx:2879
 TH1.cxx:2880
 TH1.cxx:2881
 TH1.cxx:2882
 TH1.cxx:2883
 TH1.cxx:2884
 TH1.cxx:2885
 TH1.cxx:2886
 TH1.cxx:2887
 TH1.cxx:2888
 TH1.cxx:2889
 TH1.cxx:2890
 TH1.cxx:2891
 TH1.cxx:2892
 TH1.cxx:2893
 TH1.cxx:2894
 TH1.cxx:2895
 TH1.cxx:2896
 TH1.cxx:2897
 TH1.cxx:2898
 TH1.cxx:2899
 TH1.cxx:2900
 TH1.cxx:2901
 TH1.cxx:2902
 TH1.cxx:2903
 TH1.cxx:2904
 TH1.cxx:2905
 TH1.cxx:2906
 TH1.cxx:2907
 TH1.cxx:2908
 TH1.cxx:2909
 TH1.cxx:2910
 TH1.cxx:2911
 TH1.cxx:2912
 TH1.cxx:2913
 TH1.cxx:2914
 TH1.cxx:2915
 TH1.cxx:2916
 TH1.cxx:2917
 TH1.cxx:2918
 TH1.cxx:2919
 TH1.cxx:2920
 TH1.cxx:2921
 TH1.cxx:2922
 TH1.cxx:2923
 TH1.cxx:2924
 TH1.cxx:2925
 TH1.cxx:2926
 TH1.cxx:2927
 TH1.cxx:2928
 TH1.cxx:2929
 TH1.cxx:2930
 TH1.cxx:2931
 TH1.cxx:2932
 TH1.cxx:2933
 TH1.cxx:2934
 TH1.cxx:2935
 TH1.cxx:2936
 TH1.cxx:2937
 TH1.cxx:2938
 TH1.cxx:2939
 TH1.cxx:2940
 TH1.cxx:2941
 TH1.cxx:2942
 TH1.cxx:2943
 TH1.cxx:2944
 TH1.cxx:2945
 TH1.cxx:2946
 TH1.cxx:2947
 TH1.cxx:2948
 TH1.cxx:2949
 TH1.cxx:2950
 TH1.cxx:2951
 TH1.cxx:2952
 TH1.cxx:2953
 TH1.cxx:2954
 TH1.cxx:2955
 TH1.cxx:2956
 TH1.cxx:2957
 TH1.cxx:2958
 TH1.cxx:2959
 TH1.cxx:2960
 TH1.cxx:2961
 TH1.cxx:2962
 TH1.cxx:2963
 TH1.cxx:2964
 TH1.cxx:2965
 TH1.cxx:2966
 TH1.cxx:2967
 TH1.cxx:2968
 TH1.cxx:2969
 TH1.cxx:2970
 TH1.cxx:2971
 TH1.cxx:2972
 TH1.cxx:2973
 TH1.cxx:2974
 TH1.cxx:2975
 TH1.cxx:2976
 TH1.cxx:2977
 TH1.cxx:2978
 TH1.cxx:2979
 TH1.cxx:2980
 TH1.cxx:2981
 TH1.cxx:2982
 TH1.cxx:2983
 TH1.cxx:2984
 TH1.cxx:2985
 TH1.cxx:2986
 TH1.cxx:2987
 TH1.cxx:2988
 TH1.cxx:2989
 TH1.cxx:2990
 TH1.cxx:2991
 TH1.cxx:2992
 TH1.cxx:2993
 TH1.cxx:2994
 TH1.cxx:2995
 TH1.cxx:2996
 TH1.cxx:2997
 TH1.cxx:2998
 TH1.cxx:2999
 TH1.cxx:3000
 TH1.cxx:3001
 TH1.cxx:3002
 TH1.cxx:3003
 TH1.cxx:3004
 TH1.cxx:3005
 TH1.cxx:3006
 TH1.cxx:3007
 TH1.cxx:3008
 TH1.cxx:3009
 TH1.cxx:3010
 TH1.cxx:3011
 TH1.cxx:3012
 TH1.cxx:3013
 TH1.cxx:3014
 TH1.cxx:3015
 TH1.cxx:3016
 TH1.cxx:3017
 TH1.cxx:3018
 TH1.cxx:3019
 TH1.cxx:3020
 TH1.cxx:3021
 TH1.cxx:3022
 TH1.cxx:3023
 TH1.cxx:3024
 TH1.cxx:3025
 TH1.cxx:3026
 TH1.cxx:3027
 TH1.cxx:3028
 TH1.cxx:3029
 TH1.cxx:3030
 TH1.cxx:3031
 TH1.cxx:3032
 TH1.cxx:3033
 TH1.cxx:3034
 TH1.cxx:3035
 TH1.cxx:3036
 TH1.cxx:3037
 TH1.cxx:3038
 TH1.cxx:3039
 TH1.cxx:3040
 TH1.cxx:3041
 TH1.cxx:3042
 TH1.cxx:3043
 TH1.cxx:3044
 TH1.cxx:3045
 TH1.cxx:3046
 TH1.cxx:3047
 TH1.cxx:3048
 TH1.cxx:3049
 TH1.cxx:3050
 TH1.cxx:3051
 TH1.cxx:3052
 TH1.cxx:3053
 TH1.cxx:3054
 TH1.cxx:3055
 TH1.cxx:3056
 TH1.cxx:3057
 TH1.cxx:3058
 TH1.cxx:3059
 TH1.cxx:3060
 TH1.cxx:3061
 TH1.cxx:3062
 TH1.cxx:3063
 TH1.cxx:3064
 TH1.cxx:3065
 TH1.cxx:3066
 TH1.cxx:3067
 TH1.cxx:3068
 TH1.cxx:3069
 TH1.cxx:3070
 TH1.cxx:3071
 TH1.cxx:3072
 TH1.cxx:3073
 TH1.cxx:3074
 TH1.cxx:3075
 TH1.cxx:3076
 TH1.cxx:3077
 TH1.cxx:3078
 TH1.cxx:3079
 TH1.cxx:3080
 TH1.cxx:3081
 TH1.cxx:3082
 TH1.cxx:3083
 TH1.cxx:3084
 TH1.cxx:3085
 TH1.cxx:3086
 TH1.cxx:3087
 TH1.cxx:3088
 TH1.cxx:3089
 TH1.cxx:3090
 TH1.cxx:3091
 TH1.cxx:3092
 TH1.cxx:3093
 TH1.cxx:3094
 TH1.cxx:3095
 TH1.cxx:3096
 TH1.cxx:3097
 TH1.cxx:3098
 TH1.cxx:3099
 TH1.cxx:3100
 TH1.cxx:3101
 TH1.cxx:3102
 TH1.cxx:3103
 TH1.cxx:3104
 TH1.cxx:3105
 TH1.cxx:3106
 TH1.cxx:3107
 TH1.cxx:3108
 TH1.cxx:3109
 TH1.cxx:3110
 TH1.cxx:3111
 TH1.cxx:3112
 TH1.cxx:3113
 TH1.cxx:3114
 TH1.cxx:3115
 TH1.cxx:3116
 TH1.cxx:3117
 TH1.cxx:3118
 TH1.cxx:3119
 TH1.cxx:3120
 TH1.cxx:3121
 TH1.cxx:3122
 TH1.cxx:3123
 TH1.cxx:3124
 TH1.cxx:3125
 TH1.cxx:3126
 TH1.cxx:3127
 TH1.cxx:3128
 TH1.cxx:3129
 TH1.cxx:3130
 TH1.cxx:3131
 TH1.cxx:3132
 TH1.cxx:3133
 TH1.cxx:3134
 TH1.cxx:3135
 TH1.cxx:3136
 TH1.cxx:3137
 TH1.cxx:3138
 TH1.cxx:3139
 TH1.cxx:3140
 TH1.cxx:3141
 TH1.cxx:3142
 TH1.cxx:3143
 TH1.cxx:3144
 TH1.cxx:3145
 TH1.cxx:3146
 TH1.cxx:3147
 TH1.cxx:3148
 TH1.cxx:3149
 TH1.cxx:3150
 TH1.cxx:3151
 TH1.cxx:3152
 TH1.cxx:3153
 TH1.cxx:3154
 TH1.cxx:3155
 TH1.cxx:3156
 TH1.cxx:3157
 TH1.cxx:3158
 TH1.cxx:3159
 TH1.cxx:3160
 TH1.cxx:3161
 TH1.cxx:3162
 TH1.cxx:3163
 TH1.cxx:3164
 TH1.cxx:3165
 TH1.cxx:3166
 TH1.cxx:3167
 TH1.cxx:3168
 TH1.cxx:3169
 TH1.cxx:3170
 TH1.cxx:3171
 TH1.cxx:3172
 TH1.cxx:3173
 TH1.cxx:3174
 TH1.cxx:3175
 TH1.cxx:3176
 TH1.cxx:3177
 TH1.cxx:3178
 TH1.cxx:3179
 TH1.cxx:3180
 TH1.cxx:3181
 TH1.cxx:3182
 TH1.cxx:3183
 TH1.cxx:3184
 TH1.cxx:3185
 TH1.cxx:3186
 TH1.cxx:3187
 TH1.cxx:3188
 TH1.cxx:3189
 TH1.cxx:3190
 TH1.cxx:3191
 TH1.cxx:3192
 TH1.cxx:3193
 TH1.cxx:3194
 TH1.cxx:3195
 TH1.cxx:3196
 TH1.cxx:3197
 TH1.cxx:3198
 TH1.cxx:3199
 TH1.cxx:3200
 TH1.cxx:3201
 TH1.cxx:3202
 TH1.cxx:3203
 TH1.cxx:3204
 TH1.cxx:3205
 TH1.cxx:3206
 TH1.cxx:3207
 TH1.cxx:3208
 TH1.cxx:3209
 TH1.cxx:3210
 TH1.cxx:3211
 TH1.cxx:3212
 TH1.cxx:3213
 TH1.cxx:3214
 TH1.cxx:3215
 TH1.cxx:3216
 TH1.cxx:3217
 TH1.cxx:3218
 TH1.cxx:3219
 TH1.cxx:3220
 TH1.cxx:3221
 TH1.cxx:3222
 TH1.cxx:3223
 TH1.cxx:3224
 TH1.cxx:3225
 TH1.cxx:3226
 TH1.cxx:3227
 TH1.cxx:3228
 TH1.cxx:3229
 TH1.cxx:3230
 TH1.cxx:3231
 TH1.cxx:3232
 TH1.cxx:3233
 TH1.cxx:3234
 TH1.cxx:3235
 TH1.cxx:3236
 TH1.cxx:3237
 TH1.cxx:3238
 TH1.cxx:3239
 TH1.cxx:3240
 TH1.cxx:3241
 TH1.cxx:3242
 TH1.cxx:3243
 TH1.cxx:3244
 TH1.cxx:3245
 TH1.cxx:3246
 TH1.cxx:3247
 TH1.cxx:3248
 TH1.cxx:3249
 TH1.cxx:3250
 TH1.cxx:3251
 TH1.cxx:3252
 TH1.cxx:3253
 TH1.cxx:3254
 TH1.cxx:3255
 TH1.cxx:3256
 TH1.cxx:3257
 TH1.cxx:3258
 TH1.cxx:3259
 TH1.cxx:3260
 TH1.cxx:3261
 TH1.cxx:3262
 TH1.cxx:3263
 TH1.cxx:3264
 TH1.cxx:3265
 TH1.cxx:3266
 TH1.cxx:3267
 TH1.cxx:3268
 TH1.cxx:3269
 TH1.cxx:3270
 TH1.cxx:3271
 TH1.cxx:3272
 TH1.cxx:3273
 TH1.cxx:3274
 TH1.cxx:3275
 TH1.cxx:3276
 TH1.cxx:3277
 TH1.cxx:3278
 TH1.cxx:3279
 TH1.cxx:3280
 TH1.cxx:3281
 TH1.cxx:3282
 TH1.cxx:3283
 TH1.cxx:3284
 TH1.cxx:3285
 TH1.cxx:3286
 TH1.cxx:3287
 TH1.cxx:3288
 TH1.cxx:3289
 TH1.cxx:3290
 TH1.cxx:3291
 TH1.cxx:3292
 TH1.cxx:3293
 TH1.cxx:3294
 TH1.cxx:3295
 TH1.cxx:3296
 TH1.cxx:3297
 TH1.cxx:3298
 TH1.cxx:3299
 TH1.cxx:3300
 TH1.cxx:3301
 TH1.cxx:3302
 TH1.cxx:3303
 TH1.cxx:3304
 TH1.cxx:3305
 TH1.cxx:3306
 TH1.cxx:3307
 TH1.cxx:3308
 TH1.cxx:3309
 TH1.cxx:3310
 TH1.cxx:3311
 TH1.cxx:3312
 TH1.cxx:3313
 TH1.cxx:3314
 TH1.cxx:3315
 TH1.cxx:3316
 TH1.cxx:3317
 TH1.cxx:3318
 TH1.cxx:3319
 TH1.cxx:3320
 TH1.cxx:3321
 TH1.cxx:3322
 TH1.cxx:3323
 TH1.cxx:3324
 TH1.cxx:3325
 TH1.cxx:3326
 TH1.cxx:3327
 TH1.cxx:3328
 TH1.cxx:3329
 TH1.cxx:3330
 TH1.cxx:3331
 TH1.cxx:3332
 TH1.cxx:3333
 TH1.cxx:3334
 TH1.cxx:3335
 TH1.cxx:3336
 TH1.cxx:3337
 TH1.cxx:3338
 TH1.cxx:3339
 TH1.cxx:3340
 TH1.cxx:3341
 TH1.cxx:3342
 TH1.cxx:3343
 TH1.cxx:3344
 TH1.cxx:3345
 TH1.cxx:3346
 TH1.cxx:3347
 TH1.cxx:3348
 TH1.cxx:3349
 TH1.cxx:3350
 TH1.cxx:3351
 TH1.cxx:3352
 TH1.cxx:3353
 TH1.cxx:3354
 TH1.cxx:3355
 TH1.cxx:3356
 TH1.cxx:3357
 TH1.cxx:3358
 TH1.cxx:3359
 TH1.cxx:3360
 TH1.cxx:3361
 TH1.cxx:3362
 TH1.cxx:3363
 TH1.cxx:3364
 TH1.cxx:3365
 TH1.cxx:3366
 TH1.cxx:3367
 TH1.cxx:3368
 TH1.cxx:3369
 TH1.cxx:3370
 TH1.cxx:3371
 TH1.cxx:3372
 TH1.cxx:3373
 TH1.cxx:3374
 TH1.cxx:3375
 TH1.cxx:3376
 TH1.cxx:3377
 TH1.cxx:3378
 TH1.cxx:3379
 TH1.cxx:3380
 TH1.cxx:3381
 TH1.cxx:3382
 TH1.cxx:3383
 TH1.cxx:3384
 TH1.cxx:3385
 TH1.cxx:3386
 TH1.cxx:3387
 TH1.cxx:3388
 TH1.cxx:3389
 TH1.cxx:3390
 TH1.cxx:3391
 TH1.cxx:3392
 TH1.cxx:3393
 TH1.cxx:3394
 TH1.cxx:3395
 TH1.cxx:3396
 TH1.cxx:3397
 TH1.cxx:3398
 TH1.cxx:3399
 TH1.cxx:3400
 TH1.cxx:3401
 TH1.cxx:3402
 TH1.cxx:3403
 TH1.cxx:3404
 TH1.cxx:3405
 TH1.cxx:3406
 TH1.cxx:3407
 TH1.cxx:3408
 TH1.cxx:3409
 TH1.cxx:3410
 TH1.cxx:3411
 TH1.cxx:3412
 TH1.cxx:3413
 TH1.cxx:3414
 TH1.cxx:3415
 TH1.cxx:3416
 TH1.cxx:3417
 TH1.cxx:3418
 TH1.cxx:3419
 TH1.cxx:3420
 TH1.cxx:3421
 TH1.cxx:3422
 TH1.cxx:3423
 TH1.cxx:3424
 TH1.cxx:3425
 TH1.cxx:3426
 TH1.cxx:3427
 TH1.cxx:3428
 TH1.cxx:3429
 TH1.cxx:3430
 TH1.cxx:3431
 TH1.cxx:3432
 TH1.cxx:3433
 TH1.cxx:3434
 TH1.cxx:3435
 TH1.cxx:3436
 TH1.cxx:3437
 TH1.cxx:3438
 TH1.cxx:3439
 TH1.cxx:3440
 TH1.cxx:3441
 TH1.cxx:3442
 TH1.cxx:3443
 TH1.cxx:3444
 TH1.cxx:3445
 TH1.cxx:3446
 TH1.cxx:3447
 TH1.cxx:3448
 TH1.cxx:3449
 TH1.cxx:3450
 TH1.cxx:3451
 TH1.cxx:3452
 TH1.cxx:3453
 TH1.cxx:3454
 TH1.cxx:3455
 TH1.cxx:3456
 TH1.cxx:3457
 TH1.cxx:3458
 TH1.cxx:3459
 TH1.cxx:3460
 TH1.cxx:3461
 TH1.cxx:3462
 TH1.cxx:3463
 TH1.cxx:3464
 TH1.cxx:3465
 TH1.cxx:3466
 TH1.cxx:3467
 TH1.cxx:3468
 TH1.cxx:3469
 TH1.cxx:3470
 TH1.cxx:3471
 TH1.cxx:3472
 TH1.cxx:3473
 TH1.cxx:3474
 TH1.cxx:3475
 TH1.cxx:3476
 TH1.cxx:3477
 TH1.cxx:3478
 TH1.cxx:3479
 TH1.cxx:3480
 TH1.cxx:3481
 TH1.cxx:3482
 TH1.cxx:3483
 TH1.cxx:3484
 TH1.cxx:3485
 TH1.cxx:3486
 TH1.cxx:3487
 TH1.cxx:3488
 TH1.cxx:3489
 TH1.cxx:3490
 TH1.cxx:3491
 TH1.cxx:3492
 TH1.cxx:3493
 TH1.cxx:3494
 TH1.cxx:3495
 TH1.cxx:3496
 TH1.cxx:3497
 TH1.cxx:3498
 TH1.cxx:3499
 TH1.cxx:3500
 TH1.cxx:3501
 TH1.cxx:3502
 TH1.cxx:3503
 TH1.cxx:3504
 TH1.cxx:3505
 TH1.cxx:3506
 TH1.cxx:3507
 TH1.cxx:3508
 TH1.cxx:3509
 TH1.cxx:3510
 TH1.cxx:3511
 TH1.cxx:3512
 TH1.cxx:3513
 TH1.cxx:3514
 TH1.cxx:3515
 TH1.cxx:3516
 TH1.cxx:3517
 TH1.cxx:3518
 TH1.cxx:3519
 TH1.cxx:3520
 TH1.cxx:3521
 TH1.cxx:3522
 TH1.cxx:3523
 TH1.cxx:3524
 TH1.cxx:3525
 TH1.cxx:3526
 TH1.cxx:3527
 TH1.cxx:3528
 TH1.cxx:3529
 TH1.cxx:3530
 TH1.cxx:3531
 TH1.cxx:3532
 TH1.cxx:3533
 TH1.cxx:3534
 TH1.cxx:3535
 TH1.cxx:3536
 TH1.cxx:3537
 TH1.cxx:3538
 TH1.cxx:3539
 TH1.cxx:3540
 TH1.cxx:3541
 TH1.cxx:3542
 TH1.cxx:3543
 TH1.cxx:3544
 TH1.cxx:3545
 TH1.cxx:3546
 TH1.cxx:3547
 TH1.cxx:3548
 TH1.cxx:3549
 TH1.cxx:3550
 TH1.cxx:3551
 TH1.cxx:3552
 TH1.cxx:3553
 TH1.cxx:3554
 TH1.cxx:3555
 TH1.cxx:3556
 TH1.cxx:3557
 TH1.cxx:3558
 TH1.cxx:3559
 TH1.cxx:3560
 TH1.cxx:3561
 TH1.cxx:3562
 TH1.cxx:3563
 TH1.cxx:3564
 TH1.cxx:3565
 TH1.cxx:3566
 TH1.cxx:3567
 TH1.cxx:3568
 TH1.cxx:3569
 TH1.cxx:3570
 TH1.cxx:3571
 TH1.cxx:3572
 TH1.cxx:3573
 TH1.cxx:3574
 TH1.cxx:3575
 TH1.cxx:3576
 TH1.cxx:3577
 TH1.cxx:3578
 TH1.cxx:3579
 TH1.cxx:3580
 TH1.cxx:3581
 TH1.cxx:3582
 TH1.cxx:3583
 TH1.cxx:3584
 TH1.cxx:3585
 TH1.cxx:3586
 TH1.cxx:3587
 TH1.cxx:3588
 TH1.cxx:3589
 TH1.cxx:3590
 TH1.cxx:3591
 TH1.cxx:3592
 TH1.cxx:3593
 TH1.cxx:3594
 TH1.cxx:3595
 TH1.cxx:3596
 TH1.cxx:3597
 TH1.cxx:3598
 TH1.cxx:3599
 TH1.cxx:3600
 TH1.cxx:3601
 TH1.cxx:3602
 TH1.cxx:3603
 TH1.cxx:3604
 TH1.cxx:3605
 TH1.cxx:3606
 TH1.cxx:3607
 TH1.cxx:3608
 TH1.cxx:3609
 TH1.cxx:3610
 TH1.cxx:3611
 TH1.cxx:3612
 TH1.cxx:3613
 TH1.cxx:3614
 TH1.cxx:3615
 TH1.cxx:3616
 TH1.cxx:3617
 TH1.cxx:3618
 TH1.cxx:3619
 TH1.cxx:3620
 TH1.cxx:3621
 TH1.cxx:3622
 TH1.cxx:3623
 TH1.cxx:3624
 TH1.cxx:3625
 TH1.cxx:3626
 TH1.cxx:3627
 TH1.cxx:3628
 TH1.cxx:3629
 TH1.cxx:3630
 TH1.cxx:3631
 TH1.cxx:3632
 TH1.cxx:3633
 TH1.cxx:3634
 TH1.cxx:3635
 TH1.cxx:3636
 TH1.cxx:3637
 TH1.cxx:3638
 TH1.cxx:3639
 TH1.cxx:3640
 TH1.cxx:3641
 TH1.cxx:3642
 TH1.cxx:3643
 TH1.cxx:3644
 TH1.cxx:3645
 TH1.cxx:3646
 TH1.cxx:3647
 TH1.cxx:3648
 TH1.cxx:3649
 TH1.cxx:3650
 TH1.cxx:3651
 TH1.cxx:3652
 TH1.cxx:3653
 TH1.cxx:3654
 TH1.cxx:3655
 TH1.cxx:3656
 TH1.cxx:3657
 TH1.cxx:3658
 TH1.cxx:3659
 TH1.cxx:3660
 TH1.cxx:3661
 TH1.cxx:3662
 TH1.cxx:3663
 TH1.cxx:3664
 TH1.cxx:3665
 TH1.cxx:3666
 TH1.cxx:3667
 TH1.cxx:3668
 TH1.cxx:3669
 TH1.cxx:3670
 TH1.cxx:3671
 TH1.cxx:3672
 TH1.cxx:3673
 TH1.cxx:3674
 TH1.cxx:3675
 TH1.cxx:3676
 TH1.cxx:3677
 TH1.cxx:3678
 TH1.cxx:3679
 TH1.cxx:3680
 TH1.cxx:3681
 TH1.cxx:3682
 TH1.cxx:3683
 TH1.cxx:3684
 TH1.cxx:3685
 TH1.cxx:3686
 TH1.cxx:3687
 TH1.cxx:3688
 TH1.cxx:3689
 TH1.cxx:3690
 TH1.cxx:3691
 TH1.cxx:3692
 TH1.cxx:3693
 TH1.cxx:3694
 TH1.cxx:3695
 TH1.cxx:3696
 TH1.cxx:3697
 TH1.cxx:3698
 TH1.cxx:3699
 TH1.cxx:3700
 TH1.cxx:3701
 TH1.cxx:3702
 TH1.cxx:3703
 TH1.cxx:3704
 TH1.cxx:3705
 TH1.cxx:3706
 TH1.cxx:3707
 TH1.cxx:3708
 TH1.cxx:3709
 TH1.cxx:3710
 TH1.cxx:3711
 TH1.cxx:3712
 TH1.cxx:3713
 TH1.cxx:3714
 TH1.cxx:3715
 TH1.cxx:3716
 TH1.cxx:3717
 TH1.cxx:3718
 TH1.cxx:3719
 TH1.cxx:3720
 TH1.cxx:3721
 TH1.cxx:3722
 TH1.cxx:3723
 TH1.cxx:3724
 TH1.cxx:3725
 TH1.cxx:3726
 TH1.cxx:3727
 TH1.cxx:3728
 TH1.cxx:3729
 TH1.cxx:3730
 TH1.cxx:3731
 TH1.cxx:3732
 TH1.cxx:3733
 TH1.cxx:3734
 TH1.cxx:3735
 TH1.cxx:3736
 TH1.cxx:3737
 TH1.cxx:3738
 TH1.cxx:3739
 TH1.cxx:3740
 TH1.cxx:3741
 TH1.cxx:3742
 TH1.cxx:3743
 TH1.cxx:3744
 TH1.cxx:3745
 TH1.cxx:3746
 TH1.cxx:3747
 TH1.cxx:3748
 TH1.cxx:3749
 TH1.cxx:3750
 TH1.cxx:3751
 TH1.cxx:3752
 TH1.cxx:3753
 TH1.cxx:3754
 TH1.cxx:3755
 TH1.cxx:3756
 TH1.cxx:3757
 TH1.cxx:3758
 TH1.cxx:3759
 TH1.cxx:3760
 TH1.cxx:3761
 TH1.cxx:3762
 TH1.cxx:3763
 TH1.cxx:3764
 TH1.cxx:3765
 TH1.cxx:3766
 TH1.cxx:3767
 TH1.cxx:3768
 TH1.cxx:3769
 TH1.cxx:3770
 TH1.cxx:3771
 TH1.cxx:3772
 TH1.cxx:3773
 TH1.cxx:3774
 TH1.cxx:3775
 TH1.cxx:3776
 TH1.cxx:3777
 TH1.cxx:3778
 TH1.cxx:3779
 TH1.cxx:3780
 TH1.cxx:3781
 TH1.cxx:3782
 TH1.cxx:3783
 TH1.cxx:3784
 TH1.cxx:3785
 TH1.cxx:3786
 TH1.cxx:3787
 TH1.cxx:3788
 TH1.cxx:3789
 TH1.cxx:3790
 TH1.cxx:3791
 TH1.cxx:3792
 TH1.cxx:3793
 TH1.cxx:3794
 TH1.cxx:3795
 TH1.cxx:3796
 TH1.cxx:3797
 TH1.cxx:3798
 TH1.cxx:3799
 TH1.cxx:3800
 TH1.cxx:3801
 TH1.cxx:3802
 TH1.cxx:3803
 TH1.cxx:3804
 TH1.cxx:3805
 TH1.cxx:3806
 TH1.cxx:3807
 TH1.cxx:3808
 TH1.cxx:3809
 TH1.cxx:3810
 TH1.cxx:3811
 TH1.cxx:3812
 TH1.cxx:3813
 TH1.cxx:3814
 TH1.cxx:3815
 TH1.cxx:3816
 TH1.cxx:3817
 TH1.cxx:3818
 TH1.cxx:3819
 TH1.cxx:3820
 TH1.cxx:3821
 TH1.cxx:3822
 TH1.cxx:3823
 TH1.cxx:3824
 TH1.cxx:3825
 TH1.cxx:3826
 TH1.cxx:3827
 TH1.cxx:3828
 TH1.cxx:3829
 TH1.cxx:3830
 TH1.cxx:3831
 TH1.cxx:3832
 TH1.cxx:3833
 TH1.cxx:3834
 TH1.cxx:3835
 TH1.cxx:3836
 TH1.cxx:3837
 TH1.cxx:3838
 TH1.cxx:3839
 TH1.cxx:3840
 TH1.cxx:3841
 TH1.cxx:3842
 TH1.cxx:3843
 TH1.cxx:3844
 TH1.cxx:3845
 TH1.cxx:3846
 TH1.cxx:3847
 TH1.cxx:3848
 TH1.cxx:3849
 TH1.cxx:3850
 TH1.cxx:3851
 TH1.cxx:3852
 TH1.cxx:3853
 TH1.cxx:3854
 TH1.cxx:3855
 TH1.cxx:3856
 TH1.cxx:3857
 TH1.cxx:3858
 TH1.cxx:3859
 TH1.cxx:3860
 TH1.cxx:3861
 TH1.cxx:3862
 TH1.cxx:3863
 TH1.cxx:3864
 TH1.cxx:3865
 TH1.cxx:3866
 TH1.cxx:3867
 TH1.cxx:3868
 TH1.cxx:3869
 TH1.cxx:3870
 TH1.cxx:3871
 TH1.cxx:3872
 TH1.cxx:3873
 TH1.cxx:3874
 TH1.cxx:3875
 TH1.cxx:3876
 TH1.cxx:3877
 TH1.cxx:3878
 TH1.cxx:3879
 TH1.cxx:3880
 TH1.cxx:3881
 TH1.cxx:3882
 TH1.cxx:3883
 TH1.cxx:3884
 TH1.cxx:3885
 TH1.cxx:3886
 TH1.cxx:3887
 TH1.cxx:3888
 TH1.cxx:3889
 TH1.cxx:3890
 TH1.cxx:3891
 TH1.cxx:3892
 TH1.cxx:3893
 TH1.cxx:3894
 TH1.cxx:3895
 TH1.cxx:3896
 TH1.cxx:3897
 TH1.cxx:3898
 TH1.cxx:3899
 TH1.cxx:3900
 TH1.cxx:3901
 TH1.cxx:3902
 TH1.cxx:3903
 TH1.cxx:3904
 TH1.cxx:3905
 TH1.cxx:3906
 TH1.cxx:3907
 TH1.cxx:3908
 TH1.cxx:3909
 TH1.cxx:3910
 TH1.cxx:3911
 TH1.cxx:3912
 TH1.cxx:3913
 TH1.cxx:3914
 TH1.cxx:3915
 TH1.cxx:3916
 TH1.cxx:3917
 TH1.cxx:3918
 TH1.cxx:3919
 TH1.cxx:3920
 TH1.cxx:3921
 TH1.cxx:3922
 TH1.cxx:3923
 TH1.cxx:3924
 TH1.cxx:3925
 TH1.cxx:3926
 TH1.cxx:3927
 TH1.cxx:3928
 TH1.cxx:3929
 TH1.cxx:3930
 TH1.cxx:3931
 TH1.cxx:3932
 TH1.cxx:3933
 TH1.cxx:3934
 TH1.cxx:3935
 TH1.cxx:3936
 TH1.cxx:3937
 TH1.cxx:3938
 TH1.cxx:3939
 TH1.cxx:3940
 TH1.cxx:3941
 TH1.cxx:3942
 TH1.cxx:3943
 TH1.cxx:3944
 TH1.cxx:3945
 TH1.cxx:3946
 TH1.cxx:3947
 TH1.cxx:3948
 TH1.cxx:3949
 TH1.cxx:3950
 TH1.cxx:3951
 TH1.cxx:3952
 TH1.cxx:3953
 TH1.cxx:3954
 TH1.cxx:3955
 TH1.cxx:3956
 TH1.cxx:3957
 TH1.cxx:3958
 TH1.cxx:3959
 TH1.cxx:3960
 TH1.cxx:3961
 TH1.cxx:3962
 TH1.cxx:3963
 TH1.cxx:3964
 TH1.cxx:3965
 TH1.cxx:3966
 TH1.cxx:3967
 TH1.cxx:3968
 TH1.cxx:3969
 TH1.cxx:3970
 TH1.cxx:3971
 TH1.cxx:3972
 TH1.cxx:3973
 TH1.cxx:3974
 TH1.cxx:3975
 TH1.cxx:3976
 TH1.cxx:3977
 TH1.cxx:3978
 TH1.cxx:3979
 TH1.cxx:3980
 TH1.cxx:3981
 TH1.cxx:3982
 TH1.cxx:3983
 TH1.cxx:3984
 TH1.cxx:3985
 TH1.cxx:3986
 TH1.cxx:3987
 TH1.cxx:3988
 TH1.cxx:3989
 TH1.cxx:3990
 TH1.cxx:3991
 TH1.cxx:3992
 TH1.cxx:3993
 TH1.cxx:3994
 TH1.cxx:3995
 TH1.cxx:3996
 TH1.cxx:3997
 TH1.cxx:3998
 TH1.cxx:3999
 TH1.cxx:4000
 TH1.cxx:4001
 TH1.cxx:4002
 TH1.cxx:4003
 TH1.cxx:4004
 TH1.cxx:4005
 TH1.cxx:4006
 TH1.cxx:4007
 TH1.cxx:4008
 TH1.cxx:4009
 TH1.cxx:4010
 TH1.cxx:4011
 TH1.cxx:4012
 TH1.cxx:4013
 TH1.cxx:4014
 TH1.cxx:4015
 TH1.cxx:4016
 TH1.cxx:4017
 TH1.cxx:4018
 TH1.cxx:4019
 TH1.cxx:4020
 TH1.cxx:4021
 TH1.cxx:4022
 TH1.cxx:4023
 TH1.cxx:4024
 TH1.cxx:4025
 TH1.cxx:4026
 TH1.cxx:4027
 TH1.cxx:4028
 TH1.cxx:4029
 TH1.cxx:4030
 TH1.cxx:4031
 TH1.cxx:4032
 TH1.cxx:4033
 TH1.cxx:4034
 TH1.cxx:4035
 TH1.cxx:4036
 TH1.cxx:4037
 TH1.cxx:4038
 TH1.cxx:4039
 TH1.cxx:4040
 TH1.cxx:4041
 TH1.cxx:4042
 TH1.cxx:4043
 TH1.cxx:4044
 TH1.cxx:4045
 TH1.cxx:4046
 TH1.cxx:4047
 TH1.cxx:4048
 TH1.cxx:4049
 TH1.cxx:4050
 TH1.cxx:4051
 TH1.cxx:4052
 TH1.cxx:4053
 TH1.cxx:4054
 TH1.cxx:4055
 TH1.cxx:4056
 TH1.cxx:4057
 TH1.cxx:4058
 TH1.cxx:4059
 TH1.cxx:4060
 TH1.cxx:4061
 TH1.cxx:4062
 TH1.cxx:4063
 TH1.cxx:4064
 TH1.cxx:4065
 TH1.cxx:4066
 TH1.cxx:4067
 TH1.cxx:4068
 TH1.cxx:4069
 TH1.cxx:4070
 TH1.cxx:4071
 TH1.cxx:4072
 TH1.cxx:4073
 TH1.cxx:4074
 TH1.cxx:4075
 TH1.cxx:4076
 TH1.cxx:4077
 TH1.cxx:4078
 TH1.cxx:4079
 TH1.cxx:4080
 TH1.cxx:4081
 TH1.cxx:4082
 TH1.cxx:4083
 TH1.cxx:4084
 TH1.cxx:4085
 TH1.cxx:4086
 TH1.cxx:4087
 TH1.cxx:4088
 TH1.cxx:4089
 TH1.cxx:4090
 TH1.cxx:4091
 TH1.cxx:4092
 TH1.cxx:4093
 TH1.cxx:4094
 TH1.cxx:4095
 TH1.cxx:4096
 TH1.cxx:4097
 TH1.cxx:4098
 TH1.cxx:4099
 TH1.cxx:4100
 TH1.cxx:4101
 TH1.cxx:4102
 TH1.cxx:4103
 TH1.cxx:4104
 TH1.cxx:4105
 TH1.cxx:4106
 TH1.cxx:4107
 TH1.cxx:4108
 TH1.cxx:4109
 TH1.cxx:4110
 TH1.cxx:4111
 TH1.cxx:4112
 TH1.cxx:4113
 TH1.cxx:4114
 TH1.cxx:4115
 TH1.cxx:4116
 TH1.cxx:4117
 TH1.cxx:4118
 TH1.cxx:4119
 TH1.cxx:4120
 TH1.cxx:4121
 TH1.cxx:4122
 TH1.cxx:4123
 TH1.cxx:4124
 TH1.cxx:4125
 TH1.cxx:4126
 TH1.cxx:4127
 TH1.cxx:4128
 TH1.cxx:4129
 TH1.cxx:4130
 TH1.cxx:4131
 TH1.cxx:4132
 TH1.cxx:4133
 TH1.cxx:4134
 TH1.cxx:4135
 TH1.cxx:4136
 TH1.cxx:4137
 TH1.cxx:4138
 TH1.cxx:4139
 TH1.cxx:4140
 TH1.cxx:4141
 TH1.cxx:4142
 TH1.cxx:4143
 TH1.cxx:4144
 TH1.cxx:4145
 TH1.cxx:4146
 TH1.cxx:4147
 TH1.cxx:4148
 TH1.cxx:4149
 TH1.cxx:4150
 TH1.cxx:4151
 TH1.cxx:4152
 TH1.cxx:4153
 TH1.cxx:4154
 TH1.cxx:4155
 TH1.cxx:4156
 TH1.cxx:4157
 TH1.cxx:4158
 TH1.cxx:4159
 TH1.cxx:4160
 TH1.cxx:4161
 TH1.cxx:4162
 TH1.cxx:4163
 TH1.cxx:4164
 TH1.cxx:4165
 TH1.cxx:4166
 TH1.cxx:4167
 TH1.cxx:4168
 TH1.cxx:4169
 TH1.cxx:4170
 TH1.cxx:4171
 TH1.cxx:4172
 TH1.cxx:4173
 TH1.cxx:4174
 TH1.cxx:4175
 TH1.cxx:4176
 TH1.cxx:4177
 TH1.cxx:4178
 TH1.cxx:4179
 TH1.cxx:4180
 TH1.cxx:4181
 TH1.cxx:4182
 TH1.cxx:4183
 TH1.cxx:4184
 TH1.cxx:4185
 TH1.cxx:4186
 TH1.cxx:4187
 TH1.cxx:4188
 TH1.cxx:4189
 TH1.cxx:4190
 TH1.cxx:4191
 TH1.cxx:4192
 TH1.cxx:4193
 TH1.cxx:4194
 TH1.cxx:4195
 TH1.cxx:4196
 TH1.cxx:4197
 TH1.cxx:4198
 TH1.cxx:4199
 TH1.cxx:4200
 TH1.cxx:4201
 TH1.cxx:4202
 TH1.cxx:4203
 TH1.cxx:4204
 TH1.cxx:4205
 TH1.cxx:4206
 TH1.cxx:4207
 TH1.cxx:4208
 TH1.cxx:4209
 TH1.cxx:4210
 TH1.cxx:4211
 TH1.cxx:4212
 TH1.cxx:4213
 TH1.cxx:4214
 TH1.cxx:4215
 TH1.cxx:4216
 TH1.cxx:4217
 TH1.cxx:4218
 TH1.cxx:4219
 TH1.cxx:4220
 TH1.cxx:4221
 TH1.cxx:4222
 TH1.cxx:4223
 TH1.cxx:4224
 TH1.cxx:4225
 TH1.cxx:4226
 TH1.cxx:4227
 TH1.cxx:4228
 TH1.cxx:4229
 TH1.cxx:4230
 TH1.cxx:4231
 TH1.cxx:4232
 TH1.cxx:4233
 TH1.cxx:4234
 TH1.cxx:4235
 TH1.cxx:4236
 TH1.cxx:4237
 TH1.cxx:4238
 TH1.cxx:4239
 TH1.cxx:4240
 TH1.cxx:4241
 TH1.cxx:4242
 TH1.cxx:4243
 TH1.cxx:4244
 TH1.cxx:4245
 TH1.cxx:4246
 TH1.cxx:4247
 TH1.cxx:4248
 TH1.cxx:4249
 TH1.cxx:4250
 TH1.cxx:4251
 TH1.cxx:4252
 TH1.cxx:4253
 TH1.cxx:4254
 TH1.cxx:4255
 TH1.cxx:4256
 TH1.cxx:4257
 TH1.cxx:4258
 TH1.cxx:4259
 TH1.cxx:4260
 TH1.cxx:4261
 TH1.cxx:4262
 TH1.cxx:4263
 TH1.cxx:4264
 TH1.cxx:4265
 TH1.cxx:4266
 TH1.cxx:4267
 TH1.cxx:4268
 TH1.cxx:4269
 TH1.cxx:4270
 TH1.cxx:4271
 TH1.cxx:4272
 TH1.cxx:4273
 TH1.cxx:4274
 TH1.cxx:4275
 TH1.cxx:4276
 TH1.cxx:4277
 TH1.cxx:4278
 TH1.cxx:4279
 TH1.cxx:4280
 TH1.cxx:4281
 TH1.cxx:4282
 TH1.cxx:4283
 TH1.cxx:4284
 TH1.cxx:4285
 TH1.cxx:4286
 TH1.cxx:4287
 TH1.cxx:4288
 TH1.cxx:4289
 TH1.cxx:4290
 TH1.cxx:4291
 TH1.cxx:4292
 TH1.cxx:4293
 TH1.cxx:4294
 TH1.cxx:4295
 TH1.cxx:4296
 TH1.cxx:4297
 TH1.cxx:4298
 TH1.cxx:4299
 TH1.cxx:4300
 TH1.cxx:4301
 TH1.cxx:4302
 TH1.cxx:4303
 TH1.cxx:4304
 TH1.cxx:4305
 TH1.cxx:4306
 TH1.cxx:4307
 TH1.cxx:4308
 TH1.cxx:4309
 TH1.cxx:4310
 TH1.cxx:4311
 TH1.cxx:4312
 TH1.cxx:4313
 TH1.cxx:4314
 TH1.cxx:4315
 TH1.cxx:4316
 TH1.cxx:4317
 TH1.cxx:4318
 TH1.cxx:4319
 TH1.cxx:4320
 TH1.cxx:4321
 TH1.cxx:4322
 TH1.cxx:4323
 TH1.cxx:4324
 TH1.cxx:4325
 TH1.cxx:4326
 TH1.cxx:4327
 TH1.cxx:4328
 TH1.cxx:4329
 TH1.cxx:4330
 TH1.cxx:4331
 TH1.cxx:4332
 TH1.cxx:4333
 TH1.cxx:4334
 TH1.cxx:4335
 TH1.cxx:4336
 TH1.cxx:4337
 TH1.cxx:4338
 TH1.cxx:4339
 TH1.cxx:4340
 TH1.cxx:4341
 TH1.cxx:4342
 TH1.cxx:4343
 TH1.cxx:4344
 TH1.cxx:4345
 TH1.cxx:4346
 TH1.cxx:4347
 TH1.cxx:4348
 TH1.cxx:4349
 TH1.cxx:4350
 TH1.cxx:4351
 TH1.cxx:4352
 TH1.cxx:4353
 TH1.cxx:4354
 TH1.cxx:4355
 TH1.cxx:4356
 TH1.cxx:4357
 TH1.cxx:4358
 TH1.cxx:4359
 TH1.cxx:4360
 TH1.cxx:4361
 TH1.cxx:4362
 TH1.cxx:4363
 TH1.cxx:4364
 TH1.cxx:4365
 TH1.cxx:4366
 TH1.cxx:4367
 TH1.cxx:4368
 TH1.cxx:4369
 TH1.cxx:4370
 TH1.cxx:4371
 TH1.cxx:4372
 TH1.cxx:4373
 TH1.cxx:4374
 TH1.cxx:4375
 TH1.cxx:4376
 TH1.cxx:4377
 TH1.cxx:4378
 TH1.cxx:4379
 TH1.cxx:4380
 TH1.cxx:4381
 TH1.cxx:4382
 TH1.cxx:4383
 TH1.cxx:4384
 TH1.cxx:4385
 TH1.cxx:4386
 TH1.cxx:4387
 TH1.cxx:4388
 TH1.cxx:4389
 TH1.cxx:4390
 TH1.cxx:4391
 TH1.cxx:4392
 TH1.cxx:4393
 TH1.cxx:4394
 TH1.cxx:4395
 TH1.cxx:4396
 TH1.cxx:4397
 TH1.cxx:4398
 TH1.cxx:4399
 TH1.cxx:4400
 TH1.cxx:4401
 TH1.cxx:4402
 TH1.cxx:4403
 TH1.cxx:4404
 TH1.cxx:4405
 TH1.cxx:4406
 TH1.cxx:4407
 TH1.cxx:4408
 TH1.cxx:4409
 TH1.cxx:4410
 TH1.cxx:4411
 TH1.cxx:4412
 TH1.cxx:4413
 TH1.cxx:4414
 TH1.cxx:4415
 TH1.cxx:4416
 TH1.cxx:4417
 TH1.cxx:4418
 TH1.cxx:4419
 TH1.cxx:4420
 TH1.cxx:4421
 TH1.cxx:4422
 TH1.cxx:4423
 TH1.cxx:4424
 TH1.cxx:4425
 TH1.cxx:4426
 TH1.cxx:4427
 TH1.cxx:4428
 TH1.cxx:4429
 TH1.cxx:4430
 TH1.cxx:4431
 TH1.cxx:4432
 TH1.cxx:4433
 TH1.cxx:4434
 TH1.cxx:4435
 TH1.cxx:4436
 TH1.cxx:4437
 TH1.cxx:4438
 TH1.cxx:4439
 TH1.cxx:4440
 TH1.cxx:4441
 TH1.cxx:4442
 TH1.cxx:4443
 TH1.cxx:4444
 TH1.cxx:4445
 TH1.cxx:4446
 TH1.cxx:4447
 TH1.cxx:4448
 TH1.cxx:4449
 TH1.cxx:4450
 TH1.cxx:4451
 TH1.cxx:4452
 TH1.cxx:4453
 TH1.cxx:4454
 TH1.cxx:4455
 TH1.cxx:4456
 TH1.cxx:4457
 TH1.cxx:4458
 TH1.cxx:4459
 TH1.cxx:4460
 TH1.cxx:4461
 TH1.cxx:4462
 TH1.cxx:4463
 TH1.cxx:4464
 TH1.cxx:4465
 TH1.cxx:4466
 TH1.cxx:4467
 TH1.cxx:4468
 TH1.cxx:4469
 TH1.cxx:4470
 TH1.cxx:4471
 TH1.cxx:4472
 TH1.cxx:4473
 TH1.cxx:4474
 TH1.cxx:4475
 TH1.cxx:4476
 TH1.cxx:4477
 TH1.cxx:4478
 TH1.cxx:4479
 TH1.cxx:4480
 TH1.cxx:4481
 TH1.cxx:4482
 TH1.cxx:4483
 TH1.cxx:4484
 TH1.cxx:4485
 TH1.cxx:4486
 TH1.cxx:4487
 TH1.cxx:4488
 TH1.cxx:4489
 TH1.cxx:4490
 TH1.cxx:4491
 TH1.cxx:4492
 TH1.cxx:4493
 TH1.cxx:4494
 TH1.cxx:4495
 TH1.cxx:4496
 TH1.cxx:4497
 TH1.cxx:4498
 TH1.cxx:4499
 TH1.cxx:4500
 TH1.cxx:4501
 TH1.cxx:4502
 TH1.cxx:4503
 TH1.cxx:4504
 TH1.cxx:4505
 TH1.cxx:4506
 TH1.cxx:4507
 TH1.cxx:4508
 TH1.cxx:4509
 TH1.cxx:4510
 TH1.cxx:4511
 TH1.cxx:4512
 TH1.cxx:4513
 TH1.cxx:4514
 TH1.cxx:4515
 TH1.cxx:4516
 TH1.cxx:4517
 TH1.cxx:4518
 TH1.cxx:4519
 TH1.cxx:4520
 TH1.cxx:4521
 TH1.cxx:4522
 TH1.cxx:4523
 TH1.cxx:4524
 TH1.cxx:4525
 TH1.cxx:4526
 TH1.cxx:4527
 TH1.cxx:4528
 TH1.cxx:4529
 TH1.cxx:4530
 TH1.cxx:4531
 TH1.cxx:4532
 TH1.cxx:4533
 TH1.cxx:4534
 TH1.cxx:4535
 TH1.cxx:4536
 TH1.cxx:4537
 TH1.cxx:4538
 TH1.cxx:4539
 TH1.cxx:4540
 TH1.cxx:4541
 TH1.cxx:4542
 TH1.cxx:4543
 TH1.cxx:4544
 TH1.cxx:4545
 TH1.cxx:4546
 TH1.cxx:4547
 TH1.cxx:4548
 TH1.cxx:4549
 TH1.cxx:4550
 TH1.cxx:4551
 TH1.cxx:4552
 TH1.cxx:4553
 TH1.cxx:4554
 TH1.cxx:4555
 TH1.cxx:4556
 TH1.cxx:4557
 TH1.cxx:4558
 TH1.cxx:4559
 TH1.cxx:4560
 TH1.cxx:4561
 TH1.cxx:4562
 TH1.cxx:4563
 TH1.cxx:4564
 TH1.cxx:4565
 TH1.cxx:4566
 TH1.cxx:4567
 TH1.cxx:4568
 TH1.cxx:4569
 TH1.cxx:4570
 TH1.cxx:4571
 TH1.cxx:4572
 TH1.cxx:4573
 TH1.cxx:4574
 TH1.cxx:4575
 TH1.cxx:4576
 TH1.cxx:4577
 TH1.cxx:4578
 TH1.cxx:4579
 TH1.cxx:4580
 TH1.cxx:4581
 TH1.cxx:4582
 TH1.cxx:4583
 TH1.cxx:4584
 TH1.cxx:4585
 TH1.cxx:4586
 TH1.cxx:4587
 TH1.cxx:4588
 TH1.cxx:4589
 TH1.cxx:4590
 TH1.cxx:4591
 TH1.cxx:4592
 TH1.cxx:4593
 TH1.cxx:4594
 TH1.cxx:4595
 TH1.cxx:4596
 TH1.cxx:4597
 TH1.cxx:4598
 TH1.cxx:4599
 TH1.cxx:4600
 TH1.cxx:4601
 TH1.cxx:4602
 TH1.cxx:4603
 TH1.cxx:4604
 TH1.cxx:4605
 TH1.cxx:4606
 TH1.cxx:4607
 TH1.cxx:4608
 TH1.cxx:4609
 TH1.cxx:4610
 TH1.cxx:4611
 TH1.cxx:4612
 TH1.cxx:4613
 TH1.cxx:4614
 TH1.cxx:4615
 TH1.cxx:4616
 TH1.cxx:4617
 TH1.cxx:4618
 TH1.cxx:4619
 TH1.cxx:4620
 TH1.cxx:4621
 TH1.cxx:4622
 TH1.cxx:4623
 TH1.cxx:4624
 TH1.cxx:4625
 TH1.cxx:4626
 TH1.cxx:4627
 TH1.cxx:4628
 TH1.cxx:4629
 TH1.cxx:4630
 TH1.cxx:4631
 TH1.cxx:4632
 TH1.cxx:4633
 TH1.cxx:4634
 TH1.cxx:4635
 TH1.cxx:4636
 TH1.cxx:4637
 TH1.cxx:4638
 TH1.cxx:4639
 TH1.cxx:4640
 TH1.cxx:4641
 TH1.cxx:4642
 TH1.cxx:4643
 TH1.cxx:4644
 TH1.cxx:4645
 TH1.cxx:4646
 TH1.cxx:4647
 TH1.cxx:4648
 TH1.cxx:4649
 TH1.cxx:4650
 TH1.cxx:4651
 TH1.cxx:4652
 TH1.cxx:4653
 TH1.cxx:4654
 TH1.cxx:4655
 TH1.cxx:4656
 TH1.cxx:4657
 TH1.cxx:4658
 TH1.cxx:4659
 TH1.cxx:4660
 TH1.cxx:4661
 TH1.cxx:4662
 TH1.cxx:4663
 TH1.cxx:4664
 TH1.cxx:4665
 TH1.cxx:4666
 TH1.cxx:4667
 TH1.cxx:4668
 TH1.cxx:4669
 TH1.cxx:4670
 TH1.cxx:4671
 TH1.cxx:4672
 TH1.cxx:4673
 TH1.cxx:4674
 TH1.cxx:4675
 TH1.cxx:4676
 TH1.cxx:4677
 TH1.cxx:4678
 TH1.cxx:4679
 TH1.cxx:4680
 TH1.cxx:4681
 TH1.cxx:4682
 TH1.cxx:4683
 TH1.cxx:4684
 TH1.cxx:4685
 TH1.cxx:4686
 TH1.cxx:4687
 TH1.cxx:4688
 TH1.cxx:4689
 TH1.cxx:4690
 TH1.cxx:4691
 TH1.cxx:4692
 TH1.cxx:4693
 TH1.cxx:4694
 TH1.cxx:4695
 TH1.cxx:4696
 TH1.cxx:4697
 TH1.cxx:4698
 TH1.cxx:4699
 TH1.cxx:4700
 TH1.cxx:4701
 TH1.cxx:4702
 TH1.cxx:4703
 TH1.cxx:4704
 TH1.cxx:4705
 TH1.cxx:4706
 TH1.cxx:4707
 TH1.cxx:4708
 TH1.cxx:4709
 TH1.cxx:4710
 TH1.cxx:4711
 TH1.cxx:4712
 TH1.cxx:4713
 TH1.cxx:4714
 TH1.cxx:4715
 TH1.cxx:4716
 TH1.cxx:4717
 TH1.cxx:4718
 TH1.cxx:4719
 TH1.cxx:4720
 TH1.cxx:4721
 TH1.cxx:4722
 TH1.cxx:4723
 TH1.cxx:4724
 TH1.cxx:4725
 TH1.cxx:4726
 TH1.cxx:4727
 TH1.cxx:4728
 TH1.cxx:4729
 TH1.cxx:4730
 TH1.cxx:4731
 TH1.cxx:4732
 TH1.cxx:4733
 TH1.cxx:4734
 TH1.cxx:4735
 TH1.cxx:4736
 TH1.cxx:4737
 TH1.cxx:4738
 TH1.cxx:4739
 TH1.cxx:4740
 TH1.cxx:4741
 TH1.cxx:4742
 TH1.cxx:4743
 TH1.cxx:4744
 TH1.cxx:4745
 TH1.cxx:4746
 TH1.cxx:4747
 TH1.cxx:4748
 TH1.cxx:4749
 TH1.cxx:4750
 TH1.cxx:4751
 TH1.cxx:4752
 TH1.cxx:4753
 TH1.cxx:4754
 TH1.cxx:4755
 TH1.cxx:4756
 TH1.cxx:4757
 TH1.cxx:4758
 TH1.cxx:4759
 TH1.cxx:4760
 TH1.cxx:4761
 TH1.cxx:4762
 TH1.cxx:4763
 TH1.cxx:4764
 TH1.cxx:4765
 TH1.cxx:4766
 TH1.cxx:4767
 TH1.cxx:4768
 TH1.cxx:4769
 TH1.cxx:4770
 TH1.cxx:4771
 TH1.cxx:4772
 TH1.cxx:4773
 TH1.cxx:4774
 TH1.cxx:4775
 TH1.cxx:4776
 TH1.cxx:4777
 TH1.cxx:4778
 TH1.cxx:4779
 TH1.cxx:4780
 TH1.cxx:4781
 TH1.cxx:4782
 TH1.cxx:4783
 TH1.cxx:4784
 TH1.cxx:4785
 TH1.cxx:4786
 TH1.cxx:4787
 TH1.cxx:4788
 TH1.cxx:4789
 TH1.cxx:4790
 TH1.cxx:4791
 TH1.cxx:4792
 TH1.cxx:4793
 TH1.cxx:4794
 TH1.cxx:4795
 TH1.cxx:4796
 TH1.cxx:4797
 TH1.cxx:4798
 TH1.cxx:4799
 TH1.cxx:4800
 TH1.cxx:4801
 TH1.cxx:4802
 TH1.cxx:4803
 TH1.cxx:4804
 TH1.cxx:4805
 TH1.cxx:4806
 TH1.cxx:4807
 TH1.cxx:4808
 TH1.cxx:4809
 TH1.cxx:4810
 TH1.cxx:4811
 TH1.cxx:4812
 TH1.cxx:4813
 TH1.cxx:4814
 TH1.cxx:4815
 TH1.cxx:4816
 TH1.cxx:4817
 TH1.cxx:4818
 TH1.cxx:4819
 TH1.cxx:4820
 TH1.cxx:4821
 TH1.cxx:4822
 TH1.cxx:4823
 TH1.cxx:4824
 TH1.cxx:4825
 TH1.cxx:4826
 TH1.cxx:4827
 TH1.cxx:4828
 TH1.cxx:4829
 TH1.cxx:4830
 TH1.cxx:4831
 TH1.cxx:4832
 TH1.cxx:4833
 TH1.cxx:4834
 TH1.cxx:4835
 TH1.cxx:4836
 TH1.cxx:4837
 TH1.cxx:4838
 TH1.cxx:4839
 TH1.cxx:4840
 TH1.cxx:4841
 TH1.cxx:4842
 TH1.cxx:4843
 TH1.cxx:4844
 TH1.cxx:4845
 TH1.cxx:4846
 TH1.cxx:4847
 TH1.cxx:4848
 TH1.cxx:4849
 TH1.cxx:4850
 TH1.cxx:4851
 TH1.cxx:4852
 TH1.cxx:4853
 TH1.cxx:4854
 TH1.cxx:4855
 TH1.cxx:4856
 TH1.cxx:4857
 TH1.cxx:4858
 TH1.cxx:4859
 TH1.cxx:4860
 TH1.cxx:4861
 TH1.cxx:4862
 TH1.cxx:4863
 TH1.cxx:4864
 TH1.cxx:4865
 TH1.cxx:4866
 TH1.cxx:4867
 TH1.cxx:4868
 TH1.cxx:4869
 TH1.cxx:4870
 TH1.cxx:4871
 TH1.cxx:4872
 TH1.cxx:4873
 TH1.cxx:4874
 TH1.cxx:4875
 TH1.cxx:4876
 TH1.cxx:4877
 TH1.cxx:4878
 TH1.cxx:4879
 TH1.cxx:4880
 TH1.cxx:4881
 TH1.cxx:4882
 TH1.cxx:4883
 TH1.cxx:4884
 TH1.cxx:4885
 TH1.cxx:4886
 TH1.cxx:4887
 TH1.cxx:4888
 TH1.cxx:4889
 TH1.cxx:4890
 TH1.cxx:4891
 TH1.cxx:4892
 TH1.cxx:4893
 TH1.cxx:4894
 TH1.cxx:4895
 TH1.cxx:4896
 TH1.cxx:4897
 TH1.cxx:4898
 TH1.cxx:4899
 TH1.cxx:4900
 TH1.cxx:4901
 TH1.cxx:4902
 TH1.cxx:4903
 TH1.cxx:4904
 TH1.cxx:4905
 TH1.cxx:4906
 TH1.cxx:4907
 TH1.cxx:4908
 TH1.cxx:4909
 TH1.cxx:4910
 TH1.cxx:4911
 TH1.cxx:4912
 TH1.cxx:4913
 TH1.cxx:4914
 TH1.cxx:4915
 TH1.cxx:4916
 TH1.cxx:4917
 TH1.cxx:4918
 TH1.cxx:4919
 TH1.cxx:4920
 TH1.cxx:4921
 TH1.cxx:4922
 TH1.cxx:4923
 TH1.cxx:4924
 TH1.cxx:4925
 TH1.cxx:4926
 TH1.cxx:4927
 TH1.cxx:4928
 TH1.cxx:4929
 TH1.cxx:4930
 TH1.cxx:4931
 TH1.cxx:4932
 TH1.cxx:4933
 TH1.cxx:4934
 TH1.cxx:4935
 TH1.cxx:4936
 TH1.cxx:4937
 TH1.cxx:4938
 TH1.cxx:4939
 TH1.cxx:4940
 TH1.cxx:4941
 TH1.cxx:4942
 TH1.cxx:4943
 TH1.cxx:4944
 TH1.cxx:4945
 TH1.cxx:4946
 TH1.cxx:4947
 TH1.cxx:4948
 TH1.cxx:4949
 TH1.cxx:4950
 TH1.cxx:4951
 TH1.cxx:4952
 TH1.cxx:4953
 TH1.cxx:4954
 TH1.cxx:4955
 TH1.cxx:4956
 TH1.cxx:4957
 TH1.cxx:4958
 TH1.cxx:4959
 TH1.cxx:4960
 TH1.cxx:4961
 TH1.cxx:4962
 TH1.cxx:4963
 TH1.cxx:4964
 TH1.cxx:4965
 TH1.cxx:4966
 TH1.cxx:4967
 TH1.cxx:4968
 TH1.cxx:4969
 TH1.cxx:4970
 TH1.cxx:4971
 TH1.cxx:4972
 TH1.cxx:4973
 TH1.cxx:4974
 TH1.cxx:4975
 TH1.cxx:4976
 TH1.cxx:4977
 TH1.cxx:4978
 TH1.cxx:4979
 TH1.cxx:4980
 TH1.cxx:4981
 TH1.cxx:4982
 TH1.cxx:4983
 TH1.cxx:4984
 TH1.cxx:4985
 TH1.cxx:4986
 TH1.cxx:4987
 TH1.cxx:4988
 TH1.cxx:4989
 TH1.cxx:4990
 TH1.cxx:4991
 TH1.cxx:4992
 TH1.cxx:4993
 TH1.cxx:4994
 TH1.cxx:4995
 TH1.cxx:4996
 TH1.cxx:4997
 TH1.cxx:4998
 TH1.cxx:4999
 TH1.cxx:5000
 TH1.cxx:5001
 TH1.cxx:5002
 TH1.cxx:5003
 TH1.cxx:5004
 TH1.cxx:5005
 TH1.cxx:5006
 TH1.cxx:5007
 TH1.cxx:5008
 TH1.cxx:5009
 TH1.cxx:5010
 TH1.cxx:5011
 TH1.cxx:5012
 TH1.cxx:5013
 TH1.cxx:5014
 TH1.cxx:5015
 TH1.cxx:5016
 TH1.cxx:5017
 TH1.cxx:5018
 TH1.cxx:5019
 TH1.cxx:5020
 TH1.cxx:5021
 TH1.cxx:5022
 TH1.cxx:5023
 TH1.cxx:5024
 TH1.cxx:5025
 TH1.cxx:5026
 TH1.cxx:5027
 TH1.cxx:5028
 TH1.cxx:5029
 TH1.cxx:5030
 TH1.cxx:5031
 TH1.cxx:5032
 TH1.cxx:5033
 TH1.cxx:5034
 TH1.cxx:5035
 TH1.cxx:5036
 TH1.cxx:5037
 TH1.cxx:5038
 TH1.cxx:5039
 TH1.cxx:5040
 TH1.cxx:5041
 TH1.cxx:5042
 TH1.cxx:5043
 TH1.cxx:5044
 TH1.cxx:5045
 TH1.cxx:5046
 TH1.cxx:5047
 TH1.cxx:5048
 TH1.cxx:5049
 TH1.cxx:5050
 TH1.cxx:5051
 TH1.cxx:5052
 TH1.cxx:5053
 TH1.cxx:5054
 TH1.cxx:5055
 TH1.cxx:5056
 TH1.cxx:5057
 TH1.cxx:5058
 TH1.cxx:5059
 TH1.cxx:5060
 TH1.cxx:5061
 TH1.cxx:5062
 TH1.cxx:5063
 TH1.cxx:5064
 TH1.cxx:5065
 TH1.cxx:5066
 TH1.cxx:5067
 TH1.cxx:5068
 TH1.cxx:5069
 TH1.cxx:5070
 TH1.cxx:5071
 TH1.cxx:5072
 TH1.cxx:5073
 TH1.cxx:5074
 TH1.cxx:5075
 TH1.cxx:5076
 TH1.cxx:5077
 TH1.cxx:5078
 TH1.cxx:5079
 TH1.cxx:5080
 TH1.cxx:5081
 TH1.cxx:5082
 TH1.cxx:5083
 TH1.cxx:5084
 TH1.cxx:5085
 TH1.cxx:5086
 TH1.cxx:5087
 TH1.cxx:5088
 TH1.cxx:5089
 TH1.cxx:5090
 TH1.cxx:5091
 TH1.cxx:5092
 TH1.cxx:5093
 TH1.cxx:5094
 TH1.cxx:5095
 TH1.cxx:5096
 TH1.cxx:5097
 TH1.cxx:5098
 TH1.cxx:5099
 TH1.cxx:5100
 TH1.cxx:5101
 TH1.cxx:5102
 TH1.cxx:5103
 TH1.cxx:5104
 TH1.cxx:5105
 TH1.cxx:5106
 TH1.cxx:5107
 TH1.cxx:5108
 TH1.cxx:5109
 TH1.cxx:5110
 TH1.cxx:5111
 TH1.cxx:5112
 TH1.cxx:5113
 TH1.cxx:5114
 TH1.cxx:5115
 TH1.cxx:5116
 TH1.cxx:5117
 TH1.cxx:5118
 TH1.cxx:5119
 TH1.cxx:5120
 TH1.cxx:5121
 TH1.cxx:5122
 TH1.cxx:5123
 TH1.cxx:5124
 TH1.cxx:5125
 TH1.cxx:5126
 TH1.cxx:5127
 TH1.cxx:5128
 TH1.cxx:5129
 TH1.cxx:5130
 TH1.cxx:5131
 TH1.cxx:5132
 TH1.cxx:5133
 TH1.cxx:5134
 TH1.cxx:5135
 TH1.cxx:5136
 TH1.cxx:5137
 TH1.cxx:5138
 TH1.cxx:5139
 TH1.cxx:5140
 TH1.cxx:5141
 TH1.cxx:5142
 TH1.cxx:5143
 TH1.cxx:5144
 TH1.cxx:5145
 TH1.cxx:5146
 TH1.cxx:5147
 TH1.cxx:5148
 TH1.cxx:5149
 TH1.cxx:5150
 TH1.cxx:5151
 TH1.cxx:5152
 TH1.cxx:5153
 TH1.cxx:5154
 TH1.cxx:5155
 TH1.cxx:5156
 TH1.cxx:5157
 TH1.cxx:5158
 TH1.cxx:5159
 TH1.cxx:5160
 TH1.cxx:5161
 TH1.cxx:5162
 TH1.cxx:5163
 TH1.cxx:5164
 TH1.cxx:5165
 TH1.cxx:5166
 TH1.cxx:5167
 TH1.cxx:5168
 TH1.cxx:5169
 TH1.cxx:5170
 TH1.cxx:5171
 TH1.cxx:5172
 TH1.cxx:5173
 TH1.cxx:5174
 TH1.cxx:5175
 TH1.cxx:5176
 TH1.cxx:5177
 TH1.cxx:5178
 TH1.cxx:5179
 TH1.cxx:5180
 TH1.cxx:5181
 TH1.cxx:5182
 TH1.cxx:5183
 TH1.cxx:5184
 TH1.cxx:5185
 TH1.cxx:5186
 TH1.cxx:5187
 TH1.cxx:5188
 TH1.cxx:5189
 TH1.cxx:5190
 TH1.cxx:5191
 TH1.cxx:5192
 TH1.cxx:5193
 TH1.cxx:5194
 TH1.cxx:5195
 TH1.cxx:5196
 TH1.cxx:5197
 TH1.cxx:5198
 TH1.cxx:5199
 TH1.cxx:5200
 TH1.cxx:5201
 TH1.cxx:5202
 TH1.cxx:5203
 TH1.cxx:5204
 TH1.cxx:5205
 TH1.cxx:5206
 TH1.cxx:5207
 TH1.cxx:5208
 TH1.cxx:5209
 TH1.cxx:5210
 TH1.cxx:5211
 TH1.cxx:5212
 TH1.cxx:5213
 TH1.cxx:5214
 TH1.cxx:5215
 TH1.cxx:5216
 TH1.cxx:5217
 TH1.cxx:5218
 TH1.cxx:5219
 TH1.cxx:5220
 TH1.cxx:5221
 TH1.cxx:5222
 TH1.cxx:5223
 TH1.cxx:5224
 TH1.cxx:5225
 TH1.cxx:5226
 TH1.cxx:5227
 TH1.cxx:5228
 TH1.cxx:5229
 TH1.cxx:5230
 TH1.cxx:5231
 TH1.cxx:5232
 TH1.cxx:5233
 TH1.cxx:5234
 TH1.cxx:5235
 TH1.cxx:5236
 TH1.cxx:5237
 TH1.cxx:5238
 TH1.cxx:5239
 TH1.cxx:5240
 TH1.cxx:5241
 TH1.cxx:5242
 TH1.cxx:5243
 TH1.cxx:5244
 TH1.cxx:5245
 TH1.cxx:5246
 TH1.cxx:5247
 TH1.cxx:5248
 TH1.cxx:5249
 TH1.cxx:5250
 TH1.cxx:5251
 TH1.cxx:5252
 TH1.cxx:5253
 TH1.cxx:5254
 TH1.cxx:5255
 TH1.cxx:5256
 TH1.cxx:5257
 TH1.cxx:5258
 TH1.cxx:5259
 TH1.cxx:5260
 TH1.cxx:5261
 TH1.cxx:5262
 TH1.cxx:5263
 TH1.cxx:5264
 TH1.cxx:5265
 TH1.cxx:5266
 TH1.cxx:5267
 TH1.cxx:5268
 TH1.cxx:5269
 TH1.cxx:5270
 TH1.cxx:5271
 TH1.cxx:5272
 TH1.cxx:5273
 TH1.cxx:5274
 TH1.cxx:5275
 TH1.cxx:5276
 TH1.cxx:5277
 TH1.cxx:5278
 TH1.cxx:5279
 TH1.cxx:5280
 TH1.cxx:5281
 TH1.cxx:5282
 TH1.cxx:5283
 TH1.cxx:5284
 TH1.cxx:5285
 TH1.cxx:5286
 TH1.cxx:5287
 TH1.cxx:5288
 TH1.cxx:5289
 TH1.cxx:5290
 TH1.cxx:5291
 TH1.cxx:5292
 TH1.cxx:5293
 TH1.cxx:5294
 TH1.cxx:5295
 TH1.cxx:5296
 TH1.cxx:5297
 TH1.cxx:5298
 TH1.cxx:5299
 TH1.cxx:5300
 TH1.cxx:5301
 TH1.cxx:5302
 TH1.cxx:5303
 TH1.cxx:5304
 TH1.cxx:5305
 TH1.cxx:5306
 TH1.cxx:5307
 TH1.cxx:5308
 TH1.cxx:5309
 TH1.cxx:5310
 TH1.cxx:5311
 TH1.cxx:5312
 TH1.cxx:5313
 TH1.cxx:5314
 TH1.cxx:5315
 TH1.cxx:5316
 TH1.cxx:5317
 TH1.cxx:5318
 TH1.cxx:5319
 TH1.cxx:5320
 TH1.cxx:5321
 TH1.cxx:5322
 TH1.cxx:5323
 TH1.cxx:5324
 TH1.cxx:5325
 TH1.cxx:5326
 TH1.cxx:5327
 TH1.cxx:5328
 TH1.cxx:5329
 TH1.cxx:5330
 TH1.cxx:5331
 TH1.cxx:5332
 TH1.cxx:5333
 TH1.cxx:5334
 TH1.cxx:5335
 TH1.cxx:5336
 TH1.cxx:5337
 TH1.cxx:5338
 TH1.cxx:5339
 TH1.cxx:5340
 TH1.cxx:5341
 TH1.cxx:5342
 TH1.cxx:5343
 TH1.cxx:5344
 TH1.cxx:5345
 TH1.cxx:5346
 TH1.cxx:5347
 TH1.cxx:5348
 TH1.cxx:5349
 TH1.cxx:5350
 TH1.cxx:5351
 TH1.cxx:5352
 TH1.cxx:5353
 TH1.cxx:5354
 TH1.cxx:5355
 TH1.cxx:5356
 TH1.cxx:5357
 TH1.cxx:5358
 TH1.cxx:5359
 TH1.cxx:5360
 TH1.cxx:5361
 TH1.cxx:5362
 TH1.cxx:5363
 TH1.cxx:5364
 TH1.cxx:5365
 TH1.cxx:5366
 TH1.cxx:5367
 TH1.cxx:5368
 TH1.cxx:5369
 TH1.cxx:5370
 TH1.cxx:5371
 TH1.cxx:5372
 TH1.cxx:5373
 TH1.cxx:5374
 TH1.cxx:5375
 TH1.cxx:5376
 TH1.cxx:5377
 TH1.cxx:5378
 TH1.cxx:5379
 TH1.cxx:5380
 TH1.cxx:5381
 TH1.cxx:5382
 TH1.cxx:5383
 TH1.cxx:5384
 TH1.cxx:5385
 TH1.cxx:5386
 TH1.cxx:5387
 TH1.cxx:5388
 TH1.cxx:5389
 TH1.cxx:5390
 TH1.cxx:5391
 TH1.cxx:5392
 TH1.cxx:5393
 TH1.cxx:5394
 TH1.cxx:5395
 TH1.cxx:5396
 TH1.cxx:5397
 TH1.cxx:5398
 TH1.cxx:5399
 TH1.cxx:5400
 TH1.cxx:5401
 TH1.cxx:5402
 TH1.cxx:5403
 TH1.cxx:5404
 TH1.cxx:5405
 TH1.cxx:5406
 TH1.cxx:5407
 TH1.cxx:5408
 TH1.cxx:5409
 TH1.cxx:5410
 TH1.cxx:5411
 TH1.cxx:5412
 TH1.cxx:5413
 TH1.cxx:5414
 TH1.cxx:5415
 TH1.cxx:5416
 TH1.cxx:5417
 TH1.cxx:5418
 TH1.cxx:5419
 TH1.cxx:5420
 TH1.cxx:5421
 TH1.cxx:5422
 TH1.cxx:5423
 TH1.cxx:5424
 TH1.cxx:5425
 TH1.cxx:5426
 TH1.cxx:5427
 TH1.cxx:5428
 TH1.cxx:5429
 TH1.cxx:5430
 TH1.cxx:5431
 TH1.cxx:5432
 TH1.cxx:5433
 TH1.cxx:5434
 TH1.cxx:5435
 TH1.cxx:5436
 TH1.cxx:5437
 TH1.cxx:5438
 TH1.cxx:5439
 TH1.cxx:5440
 TH1.cxx:5441
 TH1.cxx:5442
 TH1.cxx:5443
 TH1.cxx:5444
 TH1.cxx:5445
 TH1.cxx:5446
 TH1.cxx:5447
 TH1.cxx:5448
 TH1.cxx:5449
 TH1.cxx:5450
 TH1.cxx:5451
 TH1.cxx:5452
 TH1.cxx:5453
 TH1.cxx:5454
 TH1.cxx:5455
 TH1.cxx:5456
 TH1.cxx:5457
 TH1.cxx:5458
 TH1.cxx:5459
 TH1.cxx:5460
 TH1.cxx:5461
 TH1.cxx:5462
 TH1.cxx:5463
 TH1.cxx:5464
 TH1.cxx:5465
 TH1.cxx:5466
 TH1.cxx:5467
 TH1.cxx:5468
 TH1.cxx:5469
 TH1.cxx:5470
 TH1.cxx:5471
 TH1.cxx:5472
 TH1.cxx:5473
 TH1.cxx:5474
 TH1.cxx:5475
 TH1.cxx:5476
 TH1.cxx:5477
 TH1.cxx:5478
 TH1.cxx:5479
 TH1.cxx:5480
 TH1.cxx:5481
 TH1.cxx:5482
 TH1.cxx:5483
 TH1.cxx:5484
 TH1.cxx:5485
 TH1.cxx:5486
 TH1.cxx:5487
 TH1.cxx:5488
 TH1.cxx:5489
 TH1.cxx:5490
 TH1.cxx:5491
 TH1.cxx:5492
 TH1.cxx:5493
 TH1.cxx:5494
 TH1.cxx:5495
 TH1.cxx:5496
 TH1.cxx:5497
 TH1.cxx:5498
 TH1.cxx:5499
 TH1.cxx:5500
 TH1.cxx:5501
 TH1.cxx:5502
 TH1.cxx:5503
 TH1.cxx:5504
 TH1.cxx:5505
 TH1.cxx:5506
 TH1.cxx:5507
 TH1.cxx:5508
 TH1.cxx:5509
 TH1.cxx:5510
 TH1.cxx:5511
 TH1.cxx:5512
 TH1.cxx:5513
 TH1.cxx:5514
 TH1.cxx:5515
 TH1.cxx:5516
 TH1.cxx:5517
 TH1.cxx:5518
 TH1.cxx:5519
 TH1.cxx:5520
 TH1.cxx:5521
 TH1.cxx:5522
 TH1.cxx:5523
 TH1.cxx:5524
 TH1.cxx:5525
 TH1.cxx:5526
 TH1.cxx:5527
 TH1.cxx:5528
 TH1.cxx:5529
 TH1.cxx:5530
 TH1.cxx:5531
 TH1.cxx:5532
 TH1.cxx:5533
 TH1.cxx:5534
 TH1.cxx:5535
 TH1.cxx:5536
 TH1.cxx:5537
 TH1.cxx:5538
 TH1.cxx:5539
 TH1.cxx:5540
 TH1.cxx:5541
 TH1.cxx:5542
 TH1.cxx:5543
 TH1.cxx:5544
 TH1.cxx:5545
 TH1.cxx:5546
 TH1.cxx:5547
 TH1.cxx:5548
 TH1.cxx:5549
 TH1.cxx:5550
 TH1.cxx:5551
 TH1.cxx:5552
 TH1.cxx:5553
 TH1.cxx:5554
 TH1.cxx:5555
 TH1.cxx:5556
 TH1.cxx:5557
 TH1.cxx:5558
 TH1.cxx:5559
 TH1.cxx:5560
 TH1.cxx:5561
 TH1.cxx:5562
 TH1.cxx:5563
 TH1.cxx:5564
 TH1.cxx:5565
 TH1.cxx:5566
 TH1.cxx:5567
 TH1.cxx:5568
 TH1.cxx:5569
 TH1.cxx:5570
 TH1.cxx:5571
 TH1.cxx:5572
 TH1.cxx:5573
 TH1.cxx:5574
 TH1.cxx:5575
 TH1.cxx:5576
 TH1.cxx:5577
 TH1.cxx:5578
 TH1.cxx:5579
 TH1.cxx:5580
 TH1.cxx:5581
 TH1.cxx:5582
 TH1.cxx:5583
 TH1.cxx:5584
 TH1.cxx:5585
 TH1.cxx:5586
 TH1.cxx:5587
 TH1.cxx:5588
 TH1.cxx:5589
 TH1.cxx:5590
 TH1.cxx:5591
 TH1.cxx:5592
 TH1.cxx:5593
 TH1.cxx:5594
 TH1.cxx:5595
 TH1.cxx:5596
 TH1.cxx:5597
 TH1.cxx:5598
 TH1.cxx:5599
 TH1.cxx:5600
 TH1.cxx:5601
 TH1.cxx:5602
 TH1.cxx:5603
 TH1.cxx:5604
 TH1.cxx:5605
 TH1.cxx:5606
 TH1.cxx:5607
 TH1.cxx:5608
 TH1.cxx:5609
 TH1.cxx:5610
 TH1.cxx:5611
 TH1.cxx:5612
 TH1.cxx:5613
 TH1.cxx:5614
 TH1.cxx:5615
 TH1.cxx:5616
 TH1.cxx:5617
 TH1.cxx:5618
 TH1.cxx:5619
 TH1.cxx:5620
 TH1.cxx:5621
 TH1.cxx:5622
 TH1.cxx:5623
 TH1.cxx:5624
 TH1.cxx:5625
 TH1.cxx:5626
 TH1.cxx:5627
 TH1.cxx:5628
 TH1.cxx:5629
 TH1.cxx:5630
 TH1.cxx:5631
 TH1.cxx:5632
 TH1.cxx:5633
 TH1.cxx:5634
 TH1.cxx:5635
 TH1.cxx:5636
 TH1.cxx:5637
 TH1.cxx:5638
 TH1.cxx:5639
 TH1.cxx:5640
 TH1.cxx:5641
 TH1.cxx:5642
 TH1.cxx:5643
 TH1.cxx:5644
 TH1.cxx:5645
 TH1.cxx:5646
 TH1.cxx:5647
 TH1.cxx:5648
 TH1.cxx:5649
 TH1.cxx:5650
 TH1.cxx:5651
 TH1.cxx:5652
 TH1.cxx:5653
 TH1.cxx:5654
 TH1.cxx:5655
 TH1.cxx:5656
 TH1.cxx:5657
 TH1.cxx:5658
 TH1.cxx:5659
 TH1.cxx:5660
 TH1.cxx:5661
 TH1.cxx:5662
 TH1.cxx:5663
 TH1.cxx:5664
 TH1.cxx:5665
 TH1.cxx:5666
 TH1.cxx:5667
 TH1.cxx:5668
 TH1.cxx:5669
 TH1.cxx:5670
 TH1.cxx:5671
 TH1.cxx:5672
 TH1.cxx:5673
 TH1.cxx:5674
 TH1.cxx:5675
 TH1.cxx:5676
 TH1.cxx:5677
 TH1.cxx:5678
 TH1.cxx:5679
 TH1.cxx:5680
 TH1.cxx:5681
 TH1.cxx:5682
 TH1.cxx:5683
 TH1.cxx:5684
 TH1.cxx:5685
 TH1.cxx:5686
 TH1.cxx:5687
 TH1.cxx:5688
 TH1.cxx:5689
 TH1.cxx:5690
 TH1.cxx:5691
 TH1.cxx:5692
 TH1.cxx:5693
 TH1.cxx:5694
 TH1.cxx:5695
 TH1.cxx:5696
 TH1.cxx:5697
 TH1.cxx:5698
 TH1.cxx:5699
 TH1.cxx:5700
 TH1.cxx:5701
 TH1.cxx:5702
 TH1.cxx:5703
 TH1.cxx:5704
 TH1.cxx:5705
 TH1.cxx:5706
 TH1.cxx:5707
 TH1.cxx:5708
 TH1.cxx:5709
 TH1.cxx:5710
 TH1.cxx:5711
 TH1.cxx:5712
 TH1.cxx:5713
 TH1.cxx:5714
 TH1.cxx:5715
 TH1.cxx:5716
 TH1.cxx:5717
 TH1.cxx:5718
 TH1.cxx:5719
 TH1.cxx:5720
 TH1.cxx:5721
 TH1.cxx:5722
 TH1.cxx:5723
 TH1.cxx:5724
 TH1.cxx:5725
 TH1.cxx:5726
 TH1.cxx:5727
 TH1.cxx:5728
 TH1.cxx:5729
 TH1.cxx:5730
 TH1.cxx:5731
 TH1.cxx:5732
 TH1.cxx:5733
 TH1.cxx:5734
 TH1.cxx:5735
 TH1.cxx:5736
 TH1.cxx:5737
 TH1.cxx:5738
 TH1.cxx:5739
 TH1.cxx:5740
 TH1.cxx:5741
 TH1.cxx:5742
 TH1.cxx:5743
 TH1.cxx:5744
 TH1.cxx:5745
 TH1.cxx:5746
 TH1.cxx:5747
 TH1.cxx:5748
 TH1.cxx:5749
 TH1.cxx:5750
 TH1.cxx:5751
 TH1.cxx:5752
 TH1.cxx:5753
 TH1.cxx:5754
 TH1.cxx:5755
 TH1.cxx:5756
 TH1.cxx:5757
 TH1.cxx:5758
 TH1.cxx:5759
 TH1.cxx:5760
 TH1.cxx:5761
 TH1.cxx:5762
 TH1.cxx:5763
 TH1.cxx:5764
 TH1.cxx:5765
 TH1.cxx:5766
 TH1.cxx:5767
 TH1.cxx:5768
 TH1.cxx:5769
 TH1.cxx:5770
 TH1.cxx:5771
 TH1.cxx:5772
 TH1.cxx:5773
 TH1.cxx:5774
 TH1.cxx:5775
 TH1.cxx:5776
 TH1.cxx:5777
 TH1.cxx:5778
 TH1.cxx:5779
 TH1.cxx:5780
 TH1.cxx:5781
 TH1.cxx:5782
 TH1.cxx:5783
 TH1.cxx:5784
 TH1.cxx:5785
 TH1.cxx:5786
 TH1.cxx:5787
 TH1.cxx:5788
 TH1.cxx:5789
 TH1.cxx:5790
 TH1.cxx:5791
 TH1.cxx:5792
 TH1.cxx:5793
 TH1.cxx:5794
 TH1.cxx:5795
 TH1.cxx:5796
 TH1.cxx:5797
 TH1.cxx:5798
 TH1.cxx:5799
 TH1.cxx:5800
 TH1.cxx:5801
 TH1.cxx:5802
 TH1.cxx:5803
 TH1.cxx:5804
 TH1.cxx:5805
 TH1.cxx:5806
 TH1.cxx:5807
 TH1.cxx:5808
 TH1.cxx:5809
 TH1.cxx:5810
 TH1.cxx:5811
 TH1.cxx:5812
 TH1.cxx:5813
 TH1.cxx:5814
 TH1.cxx:5815
 TH1.cxx:5816
 TH1.cxx:5817
 TH1.cxx:5818
 TH1.cxx:5819
 TH1.cxx:5820
 TH1.cxx:5821
 TH1.cxx:5822
 TH1.cxx:5823
 TH1.cxx:5824
 TH1.cxx:5825
 TH1.cxx:5826
 TH1.cxx:5827
 TH1.cxx:5828
 TH1.cxx:5829
 TH1.cxx:5830
 TH1.cxx:5831
 TH1.cxx:5832
 TH1.cxx:5833
 TH1.cxx:5834
 TH1.cxx:5835
 TH1.cxx:5836
 TH1.cxx:5837
 TH1.cxx:5838
 TH1.cxx:5839
 TH1.cxx:5840
 TH1.cxx:5841
 TH1.cxx:5842
 TH1.cxx:5843
 TH1.cxx:5844
 TH1.cxx:5845
 TH1.cxx:5846
 TH1.cxx:5847
 TH1.cxx:5848
 TH1.cxx:5849
 TH1.cxx:5850
 TH1.cxx:5851
 TH1.cxx:5852
 TH1.cxx:5853
 TH1.cxx:5854
 TH1.cxx:5855
 TH1.cxx:5856
 TH1.cxx:5857
 TH1.cxx:5858
 TH1.cxx:5859
 TH1.cxx:5860
 TH1.cxx:5861
 TH1.cxx:5862
 TH1.cxx:5863
 TH1.cxx:5864
 TH1.cxx:5865
 TH1.cxx:5866
 TH1.cxx:5867
 TH1.cxx:5868
 TH1.cxx:5869
 TH1.cxx:5870
 TH1.cxx:5871
 TH1.cxx:5872
 TH1.cxx:5873
 TH1.cxx:5874
 TH1.cxx:5875
 TH1.cxx:5876
 TH1.cxx:5877
 TH1.cxx:5878
 TH1.cxx:5879
 TH1.cxx:5880
 TH1.cxx:5881
 TH1.cxx:5882
 TH1.cxx:5883
 TH1.cxx:5884
 TH1.cxx:5885
 TH1.cxx:5886
 TH1.cxx:5887
 TH1.cxx:5888
 TH1.cxx:5889
 TH1.cxx:5890
 TH1.cxx:5891
 TH1.cxx:5892
 TH1.cxx:5893
 TH1.cxx:5894
 TH1.cxx:5895
 TH1.cxx:5896
 TH1.cxx:5897
 TH1.cxx:5898
 TH1.cxx:5899
 TH1.cxx:5900
 TH1.cxx:5901
 TH1.cxx:5902
 TH1.cxx:5903
 TH1.cxx:5904
 TH1.cxx:5905
 TH1.cxx:5906
 TH1.cxx:5907
 TH1.cxx:5908
 TH1.cxx:5909
 TH1.cxx:5910
 TH1.cxx:5911
 TH1.cxx:5912
 TH1.cxx:5913
 TH1.cxx:5914
 TH1.cxx:5915
 TH1.cxx:5916
 TH1.cxx:5917
 TH1.cxx:5918
 TH1.cxx:5919
 TH1.cxx:5920
 TH1.cxx:5921
 TH1.cxx:5922
 TH1.cxx:5923
 TH1.cxx:5924
 TH1.cxx:5925
 TH1.cxx:5926
 TH1.cxx:5927
 TH1.cxx:5928
 TH1.cxx:5929
 TH1.cxx:5930
 TH1.cxx:5931
 TH1.cxx:5932
 TH1.cxx:5933
 TH1.cxx:5934
 TH1.cxx:5935
 TH1.cxx:5936
 TH1.cxx:5937
 TH1.cxx:5938
 TH1.cxx:5939
 TH1.cxx:5940
 TH1.cxx:5941
 TH1.cxx:5942
 TH1.cxx:5943
 TH1.cxx:5944
 TH1.cxx:5945
 TH1.cxx:5946
 TH1.cxx:5947
 TH1.cxx:5948
 TH1.cxx:5949
 TH1.cxx:5950
 TH1.cxx:5951
 TH1.cxx:5952
 TH1.cxx:5953
 TH1.cxx:5954
 TH1.cxx:5955
 TH1.cxx:5956
 TH1.cxx:5957
 TH1.cxx:5958
 TH1.cxx:5959
 TH1.cxx:5960
 TH1.cxx:5961
 TH1.cxx:5962
 TH1.cxx:5963
 TH1.cxx:5964
 TH1.cxx:5965
 TH1.cxx:5966
 TH1.cxx:5967
 TH1.cxx:5968
 TH1.cxx:5969
 TH1.cxx:5970
 TH1.cxx:5971
 TH1.cxx:5972
 TH1.cxx:5973
 TH1.cxx:5974
 TH1.cxx:5975
 TH1.cxx:5976
 TH1.cxx:5977
 TH1.cxx:5978
 TH1.cxx:5979
 TH1.cxx:5980
 TH1.cxx:5981
 TH1.cxx:5982
 TH1.cxx:5983
 TH1.cxx:5984
 TH1.cxx:5985
 TH1.cxx:5986
 TH1.cxx:5987
 TH1.cxx:5988
 TH1.cxx:5989
 TH1.cxx:5990
 TH1.cxx:5991
 TH1.cxx:5992
 TH1.cxx:5993
 TH1.cxx:5994
 TH1.cxx:5995
 TH1.cxx:5996
 TH1.cxx:5997
 TH1.cxx:5998
 TH1.cxx:5999
 TH1.cxx:6000
 TH1.cxx:6001
 TH1.cxx:6002
 TH1.cxx:6003
 TH1.cxx:6004
 TH1.cxx:6005
 TH1.cxx:6006
 TH1.cxx:6007
 TH1.cxx:6008
 TH1.cxx:6009
 TH1.cxx:6010
 TH1.cxx:6011
 TH1.cxx:6012
 TH1.cxx:6013
 TH1.cxx:6014
 TH1.cxx:6015
 TH1.cxx:6016
 TH1.cxx:6017
 TH1.cxx:6018
 TH1.cxx:6019
 TH1.cxx:6020
 TH1.cxx:6021
 TH1.cxx:6022
 TH1.cxx:6023
 TH1.cxx:6024
 TH1.cxx:6025
 TH1.cxx:6026
 TH1.cxx:6027
 TH1.cxx:6028
 TH1.cxx:6029
 TH1.cxx:6030
 TH1.cxx:6031
 TH1.cxx:6032
 TH1.cxx:6033
 TH1.cxx:6034
 TH1.cxx:6035
 TH1.cxx:6036
 TH1.cxx:6037
 TH1.cxx:6038
 TH1.cxx:6039
 TH1.cxx:6040
 TH1.cxx:6041
 TH1.cxx:6042
 TH1.cxx:6043
 TH1.cxx:6044
 TH1.cxx:6045
 TH1.cxx:6046
 TH1.cxx:6047
 TH1.cxx:6048
 TH1.cxx:6049
 TH1.cxx:6050
 TH1.cxx:6051
 TH1.cxx:6052
 TH1.cxx:6053
 TH1.cxx:6054
 TH1.cxx:6055
 TH1.cxx:6056
 TH1.cxx:6057
 TH1.cxx:6058
 TH1.cxx:6059
 TH1.cxx:6060
 TH1.cxx:6061
 TH1.cxx:6062
 TH1.cxx:6063
 TH1.cxx:6064
 TH1.cxx:6065
 TH1.cxx:6066
 TH1.cxx:6067
 TH1.cxx:6068
 TH1.cxx:6069
 TH1.cxx:6070
 TH1.cxx:6071
 TH1.cxx:6072
 TH1.cxx:6073
 TH1.cxx:6074
 TH1.cxx:6075
 TH1.cxx:6076
 TH1.cxx:6077
 TH1.cxx:6078
 TH1.cxx:6079
 TH1.cxx:6080
 TH1.cxx:6081
 TH1.cxx:6082
 TH1.cxx:6083
 TH1.cxx:6084
 TH1.cxx:6085
 TH1.cxx:6086
 TH1.cxx:6087
 TH1.cxx:6088
 TH1.cxx:6089
 TH1.cxx:6090
 TH1.cxx:6091
 TH1.cxx:6092
 TH1.cxx:6093
 TH1.cxx:6094
 TH1.cxx:6095
 TH1.cxx:6096
 TH1.cxx:6097
 TH1.cxx:6098
 TH1.cxx:6099
 TH1.cxx:6100
 TH1.cxx:6101
 TH1.cxx:6102
 TH1.cxx:6103
 TH1.cxx:6104
 TH1.cxx:6105
 TH1.cxx:6106
 TH1.cxx:6107
 TH1.cxx:6108
 TH1.cxx:6109
 TH1.cxx:6110
 TH1.cxx:6111
 TH1.cxx:6112
 TH1.cxx:6113
 TH1.cxx:6114
 TH1.cxx:6115
 TH1.cxx:6116
 TH1.cxx:6117
 TH1.cxx:6118
 TH1.cxx:6119
 TH1.cxx:6120
 TH1.cxx:6121
 TH1.cxx:6122
 TH1.cxx:6123
 TH1.cxx:6124
 TH1.cxx:6125
 TH1.cxx:6126
 TH1.cxx:6127
 TH1.cxx:6128
 TH1.cxx:6129
 TH1.cxx:6130
 TH1.cxx:6131
 TH1.cxx:6132
 TH1.cxx:6133
 TH1.cxx:6134
 TH1.cxx:6135
 TH1.cxx:6136
 TH1.cxx:6137
 TH1.cxx:6138
 TH1.cxx:6139
 TH1.cxx:6140
 TH1.cxx:6141
 TH1.cxx:6142
 TH1.cxx:6143
 TH1.cxx:6144
 TH1.cxx:6145
 TH1.cxx:6146
 TH1.cxx:6147
 TH1.cxx:6148
 TH1.cxx:6149
 TH1.cxx:6150
 TH1.cxx:6151
 TH1.cxx:6152
 TH1.cxx:6153
 TH1.cxx:6154
 TH1.cxx:6155
 TH1.cxx:6156
 TH1.cxx:6157
 TH1.cxx:6158
 TH1.cxx:6159
 TH1.cxx:6160
 TH1.cxx:6161
 TH1.cxx:6162
 TH1.cxx:6163
 TH1.cxx:6164
 TH1.cxx:6165
 TH1.cxx:6166
 TH1.cxx:6167
 TH1.cxx:6168
 TH1.cxx:6169
 TH1.cxx:6170
 TH1.cxx:6171
 TH1.cxx:6172
 TH1.cxx:6173
 TH1.cxx:6174
 TH1.cxx:6175
 TH1.cxx:6176
 TH1.cxx:6177
 TH1.cxx:6178
 TH1.cxx:6179
 TH1.cxx:6180
 TH1.cxx:6181
 TH1.cxx:6182
 TH1.cxx:6183
 TH1.cxx:6184
 TH1.cxx:6185
 TH1.cxx:6186
 TH1.cxx:6187
 TH1.cxx:6188
 TH1.cxx:6189
 TH1.cxx:6190
 TH1.cxx:6191
 TH1.cxx:6192
 TH1.cxx:6193
 TH1.cxx:6194
 TH1.cxx:6195
 TH1.cxx:6196
 TH1.cxx:6197
 TH1.cxx:6198
 TH1.cxx:6199
 TH1.cxx:6200
 TH1.cxx:6201
 TH1.cxx:6202
 TH1.cxx:6203
 TH1.cxx:6204
 TH1.cxx:6205
 TH1.cxx:6206
 TH1.cxx:6207
 TH1.cxx:6208
 TH1.cxx:6209
 TH1.cxx:6210
 TH1.cxx:6211
 TH1.cxx:6212
 TH1.cxx:6213
 TH1.cxx:6214
 TH1.cxx:6215
 TH1.cxx:6216
 TH1.cxx:6217
 TH1.cxx:6218
 TH1.cxx:6219
 TH1.cxx:6220
 TH1.cxx:6221
 TH1.cxx:6222
 TH1.cxx:6223
 TH1.cxx:6224
 TH1.cxx:6225
 TH1.cxx:6226
 TH1.cxx:6227
 TH1.cxx:6228
 TH1.cxx:6229
 TH1.cxx:6230
 TH1.cxx:6231
 TH1.cxx:6232
 TH1.cxx:6233
 TH1.cxx:6234
 TH1.cxx:6235
 TH1.cxx:6236
 TH1.cxx:6237
 TH1.cxx:6238
 TH1.cxx:6239
 TH1.cxx:6240
 TH1.cxx:6241
 TH1.cxx:6242
 TH1.cxx:6243
 TH1.cxx:6244
 TH1.cxx:6245
 TH1.cxx:6246
 TH1.cxx:6247
 TH1.cxx:6248
 TH1.cxx:6249
 TH1.cxx:6250
 TH1.cxx:6251
 TH1.cxx:6252
 TH1.cxx:6253
 TH1.cxx:6254
 TH1.cxx:6255
 TH1.cxx:6256
 TH1.cxx:6257
 TH1.cxx:6258
 TH1.cxx:6259
 TH1.cxx:6260
 TH1.cxx:6261
 TH1.cxx:6262
 TH1.cxx:6263
 TH1.cxx:6264
 TH1.cxx:6265
 TH1.cxx:6266
 TH1.cxx:6267
 TH1.cxx:6268
 TH1.cxx:6269
 TH1.cxx:6270
 TH1.cxx:6271
 TH1.cxx:6272
 TH1.cxx:6273
 TH1.cxx:6274
 TH1.cxx:6275
 TH1.cxx:6276
 TH1.cxx:6277
 TH1.cxx:6278
 TH1.cxx:6279
 TH1.cxx:6280
 TH1.cxx:6281
 TH1.cxx:6282
 TH1.cxx:6283
 TH1.cxx:6284
 TH1.cxx:6285
 TH1.cxx:6286
 TH1.cxx:6287
 TH1.cxx:6288
 TH1.cxx:6289
 TH1.cxx:6290
 TH1.cxx:6291
 TH1.cxx:6292
 TH1.cxx:6293
 TH1.cxx:6294
 TH1.cxx:6295
 TH1.cxx:6296
 TH1.cxx:6297
 TH1.cxx:6298
 TH1.cxx:6299
 TH1.cxx:6300
 TH1.cxx:6301
 TH1.cxx:6302
 TH1.cxx:6303
 TH1.cxx:6304
 TH1.cxx:6305
 TH1.cxx:6306
 TH1.cxx:6307
 TH1.cxx:6308
 TH1.cxx:6309
 TH1.cxx:6310
 TH1.cxx:6311
 TH1.cxx:6312
 TH1.cxx:6313
 TH1.cxx:6314
 TH1.cxx:6315
 TH1.cxx:6316
 TH1.cxx:6317
 TH1.cxx:6318
 TH1.cxx:6319
 TH1.cxx:6320
 TH1.cxx:6321
 TH1.cxx:6322
 TH1.cxx:6323
 TH1.cxx:6324
 TH1.cxx:6325
 TH1.cxx:6326
 TH1.cxx:6327
 TH1.cxx:6328
 TH1.cxx:6329
 TH1.cxx:6330
 TH1.cxx:6331
 TH1.cxx:6332
 TH1.cxx:6333
 TH1.cxx:6334
 TH1.cxx:6335
 TH1.cxx:6336
 TH1.cxx:6337
 TH1.cxx:6338
 TH1.cxx:6339
 TH1.cxx:6340
 TH1.cxx:6341
 TH1.cxx:6342
 TH1.cxx:6343
 TH1.cxx:6344
 TH1.cxx:6345
 TH1.cxx:6346
 TH1.cxx:6347
 TH1.cxx:6348
 TH1.cxx:6349
 TH1.cxx:6350
 TH1.cxx:6351
 TH1.cxx:6352
 TH1.cxx:6353
 TH1.cxx:6354
 TH1.cxx:6355
 TH1.cxx:6356
 TH1.cxx:6357
 TH1.cxx:6358
 TH1.cxx:6359
 TH1.cxx:6360
 TH1.cxx:6361
 TH1.cxx:6362
 TH1.cxx:6363
 TH1.cxx:6364
 TH1.cxx:6365
 TH1.cxx:6366
 TH1.cxx:6367
 TH1.cxx:6368
 TH1.cxx:6369
 TH1.cxx:6370
 TH1.cxx:6371
 TH1.cxx:6372
 TH1.cxx:6373
 TH1.cxx:6374
 TH1.cxx:6375
 TH1.cxx:6376
 TH1.cxx:6377
 TH1.cxx:6378
 TH1.cxx:6379
 TH1.cxx:6380
 TH1.cxx:6381
 TH1.cxx:6382
 TH1.cxx:6383
 TH1.cxx:6384
 TH1.cxx:6385
 TH1.cxx:6386
 TH1.cxx:6387
 TH1.cxx:6388
 TH1.cxx:6389
 TH1.cxx:6390
 TH1.cxx:6391
 TH1.cxx:6392
 TH1.cxx:6393
 TH1.cxx:6394
 TH1.cxx:6395
 TH1.cxx:6396
 TH1.cxx:6397
 TH1.cxx:6398
 TH1.cxx:6399
 TH1.cxx:6400
 TH1.cxx:6401
 TH1.cxx:6402
 TH1.cxx:6403
 TH1.cxx:6404
 TH1.cxx:6405
 TH1.cxx:6406
 TH1.cxx:6407
 TH1.cxx:6408
 TH1.cxx:6409
 TH1.cxx:6410
 TH1.cxx:6411
 TH1.cxx:6412
 TH1.cxx:6413
 TH1.cxx:6414
 TH1.cxx:6415
 TH1.cxx:6416
 TH1.cxx:6417
 TH1.cxx:6418
 TH1.cxx:6419
 TH1.cxx:6420
 TH1.cxx:6421
 TH1.cxx:6422
 TH1.cxx:6423
 TH1.cxx:6424
 TH1.cxx:6425
 TH1.cxx:6426
 TH1.cxx:6427
 TH1.cxx:6428
 TH1.cxx:6429
 TH1.cxx:6430
 TH1.cxx:6431
 TH1.cxx:6432
 TH1.cxx:6433
 TH1.cxx:6434
 TH1.cxx:6435
 TH1.cxx:6436
 TH1.cxx:6437
 TH1.cxx:6438
 TH1.cxx:6439
 TH1.cxx:6440
 TH1.cxx:6441
 TH1.cxx:6442
 TH1.cxx:6443
 TH1.cxx:6444
 TH1.cxx:6445
 TH1.cxx:6446
 TH1.cxx:6447
 TH1.cxx:6448
 TH1.cxx:6449
 TH1.cxx:6450
 TH1.cxx:6451
 TH1.cxx:6452
 TH1.cxx:6453
 TH1.cxx:6454
 TH1.cxx:6455
 TH1.cxx:6456
 TH1.cxx:6457
 TH1.cxx:6458
 TH1.cxx:6459
 TH1.cxx:6460
 TH1.cxx:6461
 TH1.cxx:6462
 TH1.cxx:6463
 TH1.cxx:6464
 TH1.cxx:6465
 TH1.cxx:6466
 TH1.cxx:6467
 TH1.cxx:6468
 TH1.cxx:6469
 TH1.cxx:6470
 TH1.cxx:6471
 TH1.cxx:6472
 TH1.cxx:6473
 TH1.cxx:6474
 TH1.cxx:6475
 TH1.cxx:6476
 TH1.cxx:6477
 TH1.cxx:6478
 TH1.cxx:6479
 TH1.cxx:6480
 TH1.cxx:6481
 TH1.cxx:6482
 TH1.cxx:6483
 TH1.cxx:6484
 TH1.cxx:6485
 TH1.cxx:6486
 TH1.cxx:6487
 TH1.cxx:6488
 TH1.cxx:6489
 TH1.cxx:6490
 TH1.cxx:6491
 TH1.cxx:6492
 TH1.cxx:6493
 TH1.cxx:6494
 TH1.cxx:6495
 TH1.cxx:6496
 TH1.cxx:6497
 TH1.cxx:6498
 TH1.cxx:6499
 TH1.cxx:6500
 TH1.cxx:6501
 TH1.cxx:6502
 TH1.cxx:6503
 TH1.cxx:6504
 TH1.cxx:6505
 TH1.cxx:6506
 TH1.cxx:6507
 TH1.cxx:6508
 TH1.cxx:6509
 TH1.cxx:6510
 TH1.cxx:6511
 TH1.cxx:6512
 TH1.cxx:6513
 TH1.cxx:6514
 TH1.cxx:6515
 TH1.cxx:6516
 TH1.cxx:6517
 TH1.cxx:6518
 TH1.cxx:6519
 TH1.cxx:6520
 TH1.cxx:6521
 TH1.cxx:6522
 TH1.cxx:6523
 TH1.cxx:6524
 TH1.cxx:6525
 TH1.cxx:6526
 TH1.cxx:6527
 TH1.cxx:6528
 TH1.cxx:6529
 TH1.cxx:6530
 TH1.cxx:6531
 TH1.cxx:6532
 TH1.cxx:6533
 TH1.cxx:6534
 TH1.cxx:6535
 TH1.cxx:6536
 TH1.cxx:6537
 TH1.cxx:6538
 TH1.cxx:6539
 TH1.cxx:6540
 TH1.cxx:6541
 TH1.cxx:6542
 TH1.cxx:6543
 TH1.cxx:6544
 TH1.cxx:6545
 TH1.cxx:6546
 TH1.cxx:6547
 TH1.cxx:6548
 TH1.cxx:6549
 TH1.cxx:6550
 TH1.cxx:6551
 TH1.cxx:6552
 TH1.cxx:6553
 TH1.cxx:6554
 TH1.cxx:6555
 TH1.cxx:6556
 TH1.cxx:6557
 TH1.cxx:6558
 TH1.cxx:6559
 TH1.cxx:6560
 TH1.cxx:6561
 TH1.cxx:6562
 TH1.cxx:6563
 TH1.cxx:6564
 TH1.cxx:6565
 TH1.cxx:6566
 TH1.cxx:6567
 TH1.cxx:6568
 TH1.cxx:6569
 TH1.cxx:6570
 TH1.cxx:6571
 TH1.cxx:6572
 TH1.cxx:6573
 TH1.cxx:6574
 TH1.cxx:6575
 TH1.cxx:6576
 TH1.cxx:6577
 TH1.cxx:6578
 TH1.cxx:6579
 TH1.cxx:6580
 TH1.cxx:6581
 TH1.cxx:6582
 TH1.cxx:6583
 TH1.cxx:6584
 TH1.cxx:6585
 TH1.cxx:6586
 TH1.cxx:6587
 TH1.cxx:6588
 TH1.cxx:6589
 TH1.cxx:6590
 TH1.cxx:6591
 TH1.cxx:6592
 TH1.cxx:6593
 TH1.cxx:6594
 TH1.cxx:6595
 TH1.cxx:6596
 TH1.cxx:6597
 TH1.cxx:6598
 TH1.cxx:6599
 TH1.cxx:6600
 TH1.cxx:6601
 TH1.cxx:6602
 TH1.cxx:6603
 TH1.cxx:6604
 TH1.cxx:6605
 TH1.cxx:6606
 TH1.cxx:6607
 TH1.cxx:6608
 TH1.cxx:6609
 TH1.cxx:6610
 TH1.cxx:6611
 TH1.cxx:6612
 TH1.cxx:6613
 TH1.cxx:6614
 TH1.cxx:6615
 TH1.cxx:6616
 TH1.cxx:6617
 TH1.cxx:6618
 TH1.cxx:6619
 TH1.cxx:6620
 TH1.cxx:6621
 TH1.cxx:6622
 TH1.cxx:6623
 TH1.cxx:6624
 TH1.cxx:6625
 TH1.cxx:6626
 TH1.cxx:6627
 TH1.cxx:6628
 TH1.cxx:6629
 TH1.cxx:6630
 TH1.cxx:6631
 TH1.cxx:6632
 TH1.cxx:6633
 TH1.cxx:6634
 TH1.cxx:6635
 TH1.cxx:6636
 TH1.cxx:6637
 TH1.cxx:6638
 TH1.cxx:6639
 TH1.cxx:6640
 TH1.cxx:6641
 TH1.cxx:6642
 TH1.cxx:6643
 TH1.cxx:6644
 TH1.cxx:6645
 TH1.cxx:6646
 TH1.cxx:6647
 TH1.cxx:6648
 TH1.cxx:6649
 TH1.cxx:6650
 TH1.cxx:6651
 TH1.cxx:6652
 TH1.cxx:6653
 TH1.cxx:6654
 TH1.cxx:6655
 TH1.cxx:6656
 TH1.cxx:6657
 TH1.cxx:6658
 TH1.cxx:6659
 TH1.cxx:6660
 TH1.cxx:6661
 TH1.cxx:6662
 TH1.cxx:6663
 TH1.cxx:6664
 TH1.cxx:6665
 TH1.cxx:6666
 TH1.cxx:6667
 TH1.cxx:6668
 TH1.cxx:6669
 TH1.cxx:6670
 TH1.cxx:6671
 TH1.cxx:6672
 TH1.cxx:6673
 TH1.cxx:6674
 TH1.cxx:6675
 TH1.cxx:6676
 TH1.cxx:6677
 TH1.cxx:6678
 TH1.cxx:6679
 TH1.cxx:6680
 TH1.cxx:6681
 TH1.cxx:6682
 TH1.cxx:6683
 TH1.cxx:6684
 TH1.cxx:6685
 TH1.cxx:6686
 TH1.cxx:6687
 TH1.cxx:6688
 TH1.cxx:6689
 TH1.cxx:6690
 TH1.cxx:6691
 TH1.cxx:6692
 TH1.cxx:6693
 TH1.cxx:6694
 TH1.cxx:6695
 TH1.cxx:6696
 TH1.cxx:6697
 TH1.cxx:6698
 TH1.cxx:6699
 TH1.cxx:6700
 TH1.cxx:6701
 TH1.cxx:6702
 TH1.cxx:6703
 TH1.cxx:6704
 TH1.cxx:6705
 TH1.cxx:6706
 TH1.cxx:6707
 TH1.cxx:6708
 TH1.cxx:6709
 TH1.cxx:6710
 TH1.cxx:6711
 TH1.cxx:6712
 TH1.cxx:6713
 TH1.cxx:6714
 TH1.cxx:6715
 TH1.cxx:6716
 TH1.cxx:6717
 TH1.cxx:6718
 TH1.cxx:6719
 TH1.cxx:6720
 TH1.cxx:6721
 TH1.cxx:6722
 TH1.cxx:6723
 TH1.cxx:6724
 TH1.cxx:6725
 TH1.cxx:6726
 TH1.cxx:6727
 TH1.cxx:6728
 TH1.cxx:6729
 TH1.cxx:6730
 TH1.cxx:6731
 TH1.cxx:6732
 TH1.cxx:6733
 TH1.cxx:6734
 TH1.cxx:6735
 TH1.cxx:6736
 TH1.cxx:6737
 TH1.cxx:6738
 TH1.cxx:6739
 TH1.cxx:6740
 TH1.cxx:6741
 TH1.cxx:6742
 TH1.cxx:6743
 TH1.cxx:6744
 TH1.cxx:6745
 TH1.cxx:6746
 TH1.cxx:6747
 TH1.cxx:6748
 TH1.cxx:6749
 TH1.cxx:6750
 TH1.cxx:6751
 TH1.cxx:6752
 TH1.cxx:6753
 TH1.cxx:6754
 TH1.cxx:6755
 TH1.cxx:6756
 TH1.cxx:6757
 TH1.cxx:6758
 TH1.cxx:6759
 TH1.cxx:6760
 TH1.cxx:6761
 TH1.cxx:6762
 TH1.cxx:6763
 TH1.cxx:6764
 TH1.cxx:6765
 TH1.cxx:6766
 TH1.cxx:6767
 TH1.cxx:6768
 TH1.cxx:6769
 TH1.cxx:6770
 TH1.cxx:6771
 TH1.cxx:6772
 TH1.cxx:6773
 TH1.cxx:6774
 TH1.cxx:6775
 TH1.cxx:6776
 TH1.cxx:6777
 TH1.cxx:6778
 TH1.cxx:6779
 TH1.cxx:6780
 TH1.cxx:6781
 TH1.cxx:6782
 TH1.cxx:6783
 TH1.cxx:6784
 TH1.cxx:6785
 TH1.cxx:6786
 TH1.cxx:6787
 TH1.cxx:6788
 TH1.cxx:6789
 TH1.cxx:6790
 TH1.cxx:6791
 TH1.cxx:6792
 TH1.cxx:6793
 TH1.cxx:6794
 TH1.cxx:6795
 TH1.cxx:6796
 TH1.cxx:6797
 TH1.cxx:6798
 TH1.cxx:6799
 TH1.cxx:6800
 TH1.cxx:6801
 TH1.cxx:6802
 TH1.cxx:6803
 TH1.cxx:6804
 TH1.cxx:6805
 TH1.cxx:6806
 TH1.cxx:6807
 TH1.cxx:6808
 TH1.cxx:6809
 TH1.cxx:6810
 TH1.cxx:6811
 TH1.cxx:6812
 TH1.cxx:6813
 TH1.cxx:6814
 TH1.cxx:6815
 TH1.cxx:6816
 TH1.cxx:6817
 TH1.cxx:6818
 TH1.cxx:6819
 TH1.cxx:6820
 TH1.cxx:6821
 TH1.cxx:6822
 TH1.cxx:6823
 TH1.cxx:6824
 TH1.cxx:6825
 TH1.cxx:6826
 TH1.cxx:6827
 TH1.cxx:6828
 TH1.cxx:6829
 TH1.cxx:6830
 TH1.cxx:6831
 TH1.cxx:6832
 TH1.cxx:6833
 TH1.cxx:6834
 TH1.cxx:6835
 TH1.cxx:6836
 TH1.cxx:6837
 TH1.cxx:6838
 TH1.cxx:6839
 TH1.cxx:6840
 TH1.cxx:6841
 TH1.cxx:6842
 TH1.cxx:6843
 TH1.cxx:6844
 TH1.cxx:6845
 TH1.cxx:6846
 TH1.cxx:6847
 TH1.cxx:6848
 TH1.cxx:6849
 TH1.cxx:6850
 TH1.cxx:6851
 TH1.cxx:6852
 TH1.cxx:6853
 TH1.cxx:6854
 TH1.cxx:6855
 TH1.cxx:6856
 TH1.cxx:6857
 TH1.cxx:6858
 TH1.cxx:6859
 TH1.cxx:6860
 TH1.cxx:6861
 TH1.cxx:6862
 TH1.cxx:6863
 TH1.cxx:6864
 TH1.cxx:6865
 TH1.cxx:6866
 TH1.cxx:6867
 TH1.cxx:6868
 TH1.cxx:6869
 TH1.cxx:6870
 TH1.cxx:6871
 TH1.cxx:6872
 TH1.cxx:6873
 TH1.cxx:6874
 TH1.cxx:6875
 TH1.cxx:6876
 TH1.cxx:6877
 TH1.cxx:6878
 TH1.cxx:6879
 TH1.cxx:6880
 TH1.cxx:6881
 TH1.cxx:6882
 TH1.cxx:6883
 TH1.cxx:6884
 TH1.cxx:6885
 TH1.cxx:6886
 TH1.cxx:6887
 TH1.cxx:6888
 TH1.cxx:6889
 TH1.cxx:6890
 TH1.cxx:6891
 TH1.cxx:6892
 TH1.cxx:6893
 TH1.cxx:6894
 TH1.cxx:6895
 TH1.cxx:6896
 TH1.cxx:6897
 TH1.cxx:6898
 TH1.cxx:6899
 TH1.cxx:6900
 TH1.cxx:6901
 TH1.cxx:6902
 TH1.cxx:6903
 TH1.cxx:6904
 TH1.cxx:6905
 TH1.cxx:6906
 TH1.cxx:6907
 TH1.cxx:6908
 TH1.cxx:6909
 TH1.cxx:6910
 TH1.cxx:6911
 TH1.cxx:6912
 TH1.cxx:6913
 TH1.cxx:6914
 TH1.cxx:6915
 TH1.cxx:6916
 TH1.cxx:6917
 TH1.cxx:6918
 TH1.cxx:6919
 TH1.cxx:6920
 TH1.cxx:6921
 TH1.cxx:6922
 TH1.cxx:6923
 TH1.cxx:6924
 TH1.cxx:6925
 TH1.cxx:6926
 TH1.cxx:6927
 TH1.cxx:6928
 TH1.cxx:6929
 TH1.cxx:6930
 TH1.cxx:6931
 TH1.cxx:6932
 TH1.cxx:6933
 TH1.cxx:6934
 TH1.cxx:6935
 TH1.cxx:6936
 TH1.cxx:6937
 TH1.cxx:6938
 TH1.cxx:6939
 TH1.cxx:6940
 TH1.cxx:6941
 TH1.cxx:6942
 TH1.cxx:6943
 TH1.cxx:6944
 TH1.cxx:6945
 TH1.cxx:6946
 TH1.cxx:6947
 TH1.cxx:6948
 TH1.cxx:6949
 TH1.cxx:6950
 TH1.cxx:6951
 TH1.cxx:6952
 TH1.cxx:6953
 TH1.cxx:6954
 TH1.cxx:6955
 TH1.cxx:6956
 TH1.cxx:6957
 TH1.cxx:6958
 TH1.cxx:6959
 TH1.cxx:6960
 TH1.cxx:6961
 TH1.cxx:6962
 TH1.cxx:6963
 TH1.cxx:6964
 TH1.cxx:6965
 TH1.cxx:6966
 TH1.cxx:6967
 TH1.cxx:6968
 TH1.cxx:6969
 TH1.cxx:6970
 TH1.cxx:6971
 TH1.cxx:6972
 TH1.cxx:6973
 TH1.cxx:6974
 TH1.cxx:6975
 TH1.cxx:6976
 TH1.cxx:6977
 TH1.cxx:6978
 TH1.cxx:6979
 TH1.cxx:6980
 TH1.cxx:6981
 TH1.cxx:6982
 TH1.cxx:6983
 TH1.cxx:6984
 TH1.cxx:6985
 TH1.cxx:6986
 TH1.cxx:6987
 TH1.cxx:6988
 TH1.cxx:6989
 TH1.cxx:6990
 TH1.cxx:6991
 TH1.cxx:6992
 TH1.cxx:6993
 TH1.cxx:6994
 TH1.cxx:6995
 TH1.cxx:6996
 TH1.cxx:6997
 TH1.cxx:6998
 TH1.cxx:6999
 TH1.cxx:7000
 TH1.cxx:7001
 TH1.cxx:7002
 TH1.cxx:7003
 TH1.cxx:7004
 TH1.cxx:7005
 TH1.cxx:7006
 TH1.cxx:7007
 TH1.cxx:7008
 TH1.cxx:7009
 TH1.cxx:7010
 TH1.cxx:7011
 TH1.cxx:7012
 TH1.cxx:7013
 TH1.cxx:7014
 TH1.cxx:7015
 TH1.cxx:7016
 TH1.cxx:7017
 TH1.cxx:7018
 TH1.cxx:7019
 TH1.cxx:7020
 TH1.cxx:7021
 TH1.cxx:7022
 TH1.cxx:7023
 TH1.cxx:7024
 TH1.cxx:7025
 TH1.cxx:7026
 TH1.cxx:7027
 TH1.cxx:7028
 TH1.cxx:7029
 TH1.cxx:7030
 TH1.cxx:7031
 TH1.cxx:7032
 TH1.cxx:7033
 TH1.cxx:7034
 TH1.cxx:7035
 TH1.cxx:7036
 TH1.cxx:7037
 TH1.cxx:7038
 TH1.cxx:7039
 TH1.cxx:7040
 TH1.cxx:7041
 TH1.cxx:7042
 TH1.cxx:7043
 TH1.cxx:7044
 TH1.cxx:7045
 TH1.cxx:7046
 TH1.cxx:7047
 TH1.cxx:7048
 TH1.cxx:7049
 TH1.cxx:7050
 TH1.cxx:7051
 TH1.cxx:7052
 TH1.cxx:7053
 TH1.cxx:7054
 TH1.cxx:7055
 TH1.cxx:7056
 TH1.cxx:7057
 TH1.cxx:7058
 TH1.cxx:7059
 TH1.cxx:7060
 TH1.cxx:7061
 TH1.cxx:7062
 TH1.cxx:7063
 TH1.cxx:7064
 TH1.cxx:7065
 TH1.cxx:7066
 TH1.cxx:7067
 TH1.cxx:7068
 TH1.cxx:7069
 TH1.cxx:7070
 TH1.cxx:7071
 TH1.cxx:7072
 TH1.cxx:7073
 TH1.cxx:7074
 TH1.cxx:7075
 TH1.cxx:7076
 TH1.cxx:7077
 TH1.cxx:7078
 TH1.cxx:7079
 TH1.cxx:7080
 TH1.cxx:7081
 TH1.cxx:7082
 TH1.cxx:7083
 TH1.cxx:7084
 TH1.cxx:7085
 TH1.cxx:7086
 TH1.cxx:7087
 TH1.cxx:7088
 TH1.cxx:7089
 TH1.cxx:7090
 TH1.cxx:7091
 TH1.cxx:7092
 TH1.cxx:7093
 TH1.cxx:7094
 TH1.cxx:7095
 TH1.cxx:7096
 TH1.cxx:7097
 TH1.cxx:7098
 TH1.cxx:7099
 TH1.cxx:7100
 TH1.cxx:7101
 TH1.cxx:7102
 TH1.cxx:7103
 TH1.cxx:7104
 TH1.cxx:7105
 TH1.cxx:7106
 TH1.cxx:7107
 TH1.cxx:7108
 TH1.cxx:7109
 TH1.cxx:7110
 TH1.cxx:7111
 TH1.cxx:7112
 TH1.cxx:7113
 TH1.cxx:7114
 TH1.cxx:7115
 TH1.cxx:7116
 TH1.cxx:7117
 TH1.cxx:7118
 TH1.cxx:7119
 TH1.cxx:7120
 TH1.cxx:7121
 TH1.cxx:7122
 TH1.cxx:7123
 TH1.cxx:7124
 TH1.cxx:7125
 TH1.cxx:7126
 TH1.cxx:7127
 TH1.cxx:7128
 TH1.cxx:7129
 TH1.cxx:7130
 TH1.cxx:7131
 TH1.cxx:7132
 TH1.cxx:7133
 TH1.cxx:7134
 TH1.cxx:7135
 TH1.cxx:7136
 TH1.cxx:7137
 TH1.cxx:7138
 TH1.cxx:7139
 TH1.cxx:7140
 TH1.cxx:7141
 TH1.cxx:7142
 TH1.cxx:7143
 TH1.cxx:7144
 TH1.cxx:7145
 TH1.cxx:7146
 TH1.cxx:7147
 TH1.cxx:7148
 TH1.cxx:7149
 TH1.cxx:7150
 TH1.cxx:7151
 TH1.cxx:7152
 TH1.cxx:7153
 TH1.cxx:7154
 TH1.cxx:7155
 TH1.cxx:7156
 TH1.cxx:7157
 TH1.cxx:7158
 TH1.cxx:7159
 TH1.cxx:7160
 TH1.cxx:7161
 TH1.cxx:7162
 TH1.cxx:7163
 TH1.cxx:7164
 TH1.cxx:7165
 TH1.cxx:7166
 TH1.cxx:7167
 TH1.cxx:7168
 TH1.cxx:7169
 TH1.cxx:7170
 TH1.cxx:7171
 TH1.cxx:7172
 TH1.cxx:7173
 TH1.cxx:7174
 TH1.cxx:7175
 TH1.cxx:7176
 TH1.cxx:7177
 TH1.cxx:7178
 TH1.cxx:7179
 TH1.cxx:7180
 TH1.cxx:7181
 TH1.cxx:7182
 TH1.cxx:7183
 TH1.cxx:7184
 TH1.cxx:7185
 TH1.cxx:7186
 TH1.cxx:7187
 TH1.cxx:7188
 TH1.cxx:7189
 TH1.cxx:7190
 TH1.cxx:7191
 TH1.cxx:7192
 TH1.cxx:7193
 TH1.cxx:7194
 TH1.cxx:7195
 TH1.cxx:7196
 TH1.cxx:7197
 TH1.cxx:7198
 TH1.cxx:7199
 TH1.cxx:7200
 TH1.cxx:7201
 TH1.cxx:7202
 TH1.cxx:7203
 TH1.cxx:7204
 TH1.cxx:7205
 TH1.cxx:7206
 TH1.cxx:7207
 TH1.cxx:7208
 TH1.cxx:7209
 TH1.cxx:7210
 TH1.cxx:7211
 TH1.cxx:7212
 TH1.cxx:7213
 TH1.cxx:7214
 TH1.cxx:7215
 TH1.cxx:7216
 TH1.cxx:7217
 TH1.cxx:7218
 TH1.cxx:7219
 TH1.cxx:7220
 TH1.cxx:7221
 TH1.cxx:7222
 TH1.cxx:7223
 TH1.cxx:7224
 TH1.cxx:7225
 TH1.cxx:7226
 TH1.cxx:7227
 TH1.cxx:7228
 TH1.cxx:7229
 TH1.cxx:7230
 TH1.cxx:7231
 TH1.cxx:7232
 TH1.cxx:7233
 TH1.cxx:7234
 TH1.cxx:7235
 TH1.cxx:7236
 TH1.cxx:7237
 TH1.cxx:7238
 TH1.cxx:7239
 TH1.cxx:7240
 TH1.cxx:7241
 TH1.cxx:7242
 TH1.cxx:7243
 TH1.cxx:7244
 TH1.cxx:7245
 TH1.cxx:7246
 TH1.cxx:7247
 TH1.cxx:7248
 TH1.cxx:7249
 TH1.cxx:7250
 TH1.cxx:7251
 TH1.cxx:7252
 TH1.cxx:7253
 TH1.cxx:7254
 TH1.cxx:7255
 TH1.cxx:7256
 TH1.cxx:7257
 TH1.cxx:7258
 TH1.cxx:7259
 TH1.cxx:7260
 TH1.cxx:7261
 TH1.cxx:7262
 TH1.cxx:7263
 TH1.cxx:7264
 TH1.cxx:7265
 TH1.cxx:7266
 TH1.cxx:7267
 TH1.cxx:7268
 TH1.cxx:7269
 TH1.cxx:7270
 TH1.cxx:7271
 TH1.cxx:7272
 TH1.cxx:7273
 TH1.cxx:7274
 TH1.cxx:7275
 TH1.cxx:7276
 TH1.cxx:7277
 TH1.cxx:7278
 TH1.cxx:7279
 TH1.cxx:7280
 TH1.cxx:7281
 TH1.cxx:7282
 TH1.cxx:7283
 TH1.cxx:7284
 TH1.cxx:7285
 TH1.cxx:7286
 TH1.cxx:7287
 TH1.cxx:7288
 TH1.cxx:7289
 TH1.cxx:7290
 TH1.cxx:7291
 TH1.cxx:7292
 TH1.cxx:7293
 TH1.cxx:7294
 TH1.cxx:7295
 TH1.cxx:7296
 TH1.cxx:7297
 TH1.cxx:7298
 TH1.cxx:7299
 TH1.cxx:7300
 TH1.cxx:7301
 TH1.cxx:7302
 TH1.cxx:7303
 TH1.cxx:7304
 TH1.cxx:7305
 TH1.cxx:7306
 TH1.cxx:7307
 TH1.cxx:7308
 TH1.cxx:7309
 TH1.cxx:7310
 TH1.cxx:7311
 TH1.cxx:7312
 TH1.cxx:7313
 TH1.cxx:7314
 TH1.cxx:7315
 TH1.cxx:7316
 TH1.cxx:7317
 TH1.cxx:7318
 TH1.cxx:7319
 TH1.cxx:7320
 TH1.cxx:7321
 TH1.cxx:7322
 TH1.cxx:7323
 TH1.cxx:7324
 TH1.cxx:7325
 TH1.cxx:7326
 TH1.cxx:7327
 TH1.cxx:7328
 TH1.cxx:7329
 TH1.cxx:7330
 TH1.cxx:7331
 TH1.cxx:7332
 TH1.cxx:7333
 TH1.cxx:7334
 TH1.cxx:7335
 TH1.cxx:7336
 TH1.cxx:7337
 TH1.cxx:7338
 TH1.cxx:7339
 TH1.cxx:7340
 TH1.cxx:7341
 TH1.cxx:7342
 TH1.cxx:7343
 TH1.cxx:7344
 TH1.cxx:7345
 TH1.cxx:7346
 TH1.cxx:7347
 TH1.cxx:7348
 TH1.cxx:7349
 TH1.cxx:7350
 TH1.cxx:7351
 TH1.cxx:7352
 TH1.cxx:7353
 TH1.cxx:7354
 TH1.cxx:7355
 TH1.cxx:7356
 TH1.cxx:7357
 TH1.cxx:7358
 TH1.cxx:7359
 TH1.cxx:7360
 TH1.cxx:7361
 TH1.cxx:7362
 TH1.cxx:7363
 TH1.cxx:7364
 TH1.cxx:7365
 TH1.cxx:7366
 TH1.cxx:7367
 TH1.cxx:7368
 TH1.cxx:7369
 TH1.cxx:7370
 TH1.cxx:7371
 TH1.cxx:7372
 TH1.cxx:7373
 TH1.cxx:7374
 TH1.cxx:7375
 TH1.cxx:7376
 TH1.cxx:7377
 TH1.cxx:7378
 TH1.cxx:7379
 TH1.cxx:7380
 TH1.cxx:7381
 TH1.cxx:7382
 TH1.cxx:7383
 TH1.cxx:7384
 TH1.cxx:7385
 TH1.cxx:7386
 TH1.cxx:7387
 TH1.cxx:7388
 TH1.cxx:7389
 TH1.cxx:7390
 TH1.cxx:7391
 TH1.cxx:7392
 TH1.cxx:7393
 TH1.cxx:7394
 TH1.cxx:7395
 TH1.cxx:7396
 TH1.cxx:7397
 TH1.cxx:7398
 TH1.cxx:7399
 TH1.cxx:7400
 TH1.cxx:7401
 TH1.cxx:7402
 TH1.cxx:7403
 TH1.cxx:7404
 TH1.cxx:7405
 TH1.cxx:7406
 TH1.cxx:7407
 TH1.cxx:7408
 TH1.cxx:7409
 TH1.cxx:7410
 TH1.cxx:7411
 TH1.cxx:7412
 TH1.cxx:7413
 TH1.cxx:7414
 TH1.cxx:7415
 TH1.cxx:7416
 TH1.cxx:7417
 TH1.cxx:7418
 TH1.cxx:7419
 TH1.cxx:7420
 TH1.cxx:7421
 TH1.cxx:7422
 TH1.cxx:7423
 TH1.cxx:7424
 TH1.cxx:7425
 TH1.cxx:7426
 TH1.cxx:7427
 TH1.cxx:7428
 TH1.cxx:7429
 TH1.cxx:7430
 TH1.cxx:7431
 TH1.cxx:7432
 TH1.cxx:7433
 TH1.cxx:7434
 TH1.cxx:7435
 TH1.cxx:7436
 TH1.cxx:7437
 TH1.cxx:7438
 TH1.cxx:7439
 TH1.cxx:7440
 TH1.cxx:7441
 TH1.cxx:7442
 TH1.cxx:7443
 TH1.cxx:7444
 TH1.cxx:7445
 TH1.cxx:7446
 TH1.cxx:7447
 TH1.cxx:7448
 TH1.cxx:7449
 TH1.cxx:7450
 TH1.cxx:7451
 TH1.cxx:7452
 TH1.cxx:7453
 TH1.cxx:7454
 TH1.cxx:7455
 TH1.cxx:7456
 TH1.cxx:7457
 TH1.cxx:7458
 TH1.cxx:7459
 TH1.cxx:7460
 TH1.cxx:7461
 TH1.cxx:7462
 TH1.cxx:7463
 TH1.cxx:7464
 TH1.cxx:7465
 TH1.cxx:7466
 TH1.cxx:7467
 TH1.cxx:7468
 TH1.cxx:7469
 TH1.cxx:7470
 TH1.cxx:7471
 TH1.cxx:7472
 TH1.cxx:7473
 TH1.cxx:7474
 TH1.cxx:7475
 TH1.cxx:7476
 TH1.cxx:7477
 TH1.cxx:7478
 TH1.cxx:7479
 TH1.cxx:7480
 TH1.cxx:7481
 TH1.cxx:7482
 TH1.cxx:7483
 TH1.cxx:7484
 TH1.cxx:7485
 TH1.cxx:7486
 TH1.cxx:7487
 TH1.cxx:7488
 TH1.cxx:7489
 TH1.cxx:7490
 TH1.cxx:7491
 TH1.cxx:7492
 TH1.cxx:7493
 TH1.cxx:7494
 TH1.cxx:7495
 TH1.cxx:7496
 TH1.cxx:7497
 TH1.cxx:7498
 TH1.cxx:7499
 TH1.cxx:7500
 TH1.cxx:7501
 TH1.cxx:7502
 TH1.cxx:7503
 TH1.cxx:7504
 TH1.cxx:7505
 TH1.cxx:7506
 TH1.cxx:7507
 TH1.cxx:7508
 TH1.cxx:7509
 TH1.cxx:7510
 TH1.cxx:7511
 TH1.cxx:7512
 TH1.cxx:7513
 TH1.cxx:7514
 TH1.cxx:7515
 TH1.cxx:7516
 TH1.cxx:7517
 TH1.cxx:7518
 TH1.cxx:7519
 TH1.cxx:7520
 TH1.cxx:7521
 TH1.cxx:7522
 TH1.cxx:7523
 TH1.cxx:7524
 TH1.cxx:7525
 TH1.cxx:7526
 TH1.cxx:7527
 TH1.cxx:7528
 TH1.cxx:7529
 TH1.cxx:7530
 TH1.cxx:7531
 TH1.cxx:7532
 TH1.cxx:7533
 TH1.cxx:7534
 TH1.cxx:7535
 TH1.cxx:7536
 TH1.cxx:7537
 TH1.cxx:7538
 TH1.cxx:7539
 TH1.cxx:7540
 TH1.cxx:7541
 TH1.cxx:7542
 TH1.cxx:7543
 TH1.cxx:7544
 TH1.cxx:7545
 TH1.cxx:7546
 TH1.cxx:7547
 TH1.cxx:7548
 TH1.cxx:7549
 TH1.cxx:7550
 TH1.cxx:7551
 TH1.cxx:7552
 TH1.cxx:7553
 TH1.cxx:7554
 TH1.cxx:7555
 TH1.cxx:7556
 TH1.cxx:7557
 TH1.cxx:7558
 TH1.cxx:7559
 TH1.cxx:7560
 TH1.cxx:7561
 TH1.cxx:7562
 TH1.cxx:7563
 TH1.cxx:7564
 TH1.cxx:7565
 TH1.cxx:7566
 TH1.cxx:7567
 TH1.cxx:7568
 TH1.cxx:7569
 TH1.cxx:7570
 TH1.cxx:7571
 TH1.cxx:7572
 TH1.cxx:7573
 TH1.cxx:7574
 TH1.cxx:7575
 TH1.cxx:7576
 TH1.cxx:7577
 TH1.cxx:7578
 TH1.cxx:7579
 TH1.cxx:7580
 TH1.cxx:7581
 TH1.cxx:7582
 TH1.cxx:7583
 TH1.cxx:7584
 TH1.cxx:7585
 TH1.cxx:7586
 TH1.cxx:7587
 TH1.cxx:7588
 TH1.cxx:7589
 TH1.cxx:7590
 TH1.cxx:7591
 TH1.cxx:7592
 TH1.cxx:7593
 TH1.cxx:7594
 TH1.cxx:7595
 TH1.cxx:7596
 TH1.cxx:7597
 TH1.cxx:7598
 TH1.cxx:7599
 TH1.cxx:7600
 TH1.cxx:7601
 TH1.cxx:7602
 TH1.cxx:7603
 TH1.cxx:7604
 TH1.cxx:7605
 TH1.cxx:7606
 TH1.cxx:7607
 TH1.cxx:7608
 TH1.cxx:7609
 TH1.cxx:7610
 TH1.cxx:7611
 TH1.cxx:7612
 TH1.cxx:7613
 TH1.cxx:7614
 TH1.cxx:7615
 TH1.cxx:7616
 TH1.cxx:7617
 TH1.cxx:7618
 TH1.cxx:7619
 TH1.cxx:7620
 TH1.cxx:7621
 TH1.cxx:7622
 TH1.cxx:7623
 TH1.cxx:7624
 TH1.cxx:7625
 TH1.cxx:7626
 TH1.cxx:7627
 TH1.cxx:7628
 TH1.cxx:7629
 TH1.cxx:7630
 TH1.cxx:7631
 TH1.cxx:7632
 TH1.cxx:7633
 TH1.cxx:7634
 TH1.cxx:7635
 TH1.cxx:7636
 TH1.cxx:7637
 TH1.cxx:7638
 TH1.cxx:7639
 TH1.cxx:7640
 TH1.cxx:7641
 TH1.cxx:7642
 TH1.cxx:7643
 TH1.cxx:7644
 TH1.cxx:7645
 TH1.cxx:7646
 TH1.cxx:7647
 TH1.cxx:7648
 TH1.cxx:7649
 TH1.cxx:7650
 TH1.cxx:7651
 TH1.cxx:7652
 TH1.cxx:7653
 TH1.cxx:7654
 TH1.cxx:7655
 TH1.cxx:7656
 TH1.cxx:7657
 TH1.cxx:7658
 TH1.cxx:7659
 TH1.cxx:7660
 TH1.cxx:7661
 TH1.cxx:7662
 TH1.cxx:7663
 TH1.cxx:7664
 TH1.cxx:7665
 TH1.cxx:7666
 TH1.cxx:7667
 TH1.cxx:7668
 TH1.cxx:7669
 TH1.cxx:7670
 TH1.cxx:7671
 TH1.cxx:7672
 TH1.cxx:7673
 TH1.cxx:7674
 TH1.cxx:7675
 TH1.cxx:7676
 TH1.cxx:7677
 TH1.cxx:7678
 TH1.cxx:7679
 TH1.cxx:7680
 TH1.cxx:7681
 TH1.cxx:7682
 TH1.cxx:7683
 TH1.cxx:7684
 TH1.cxx:7685
 TH1.cxx:7686
 TH1.cxx:7687
 TH1.cxx:7688
 TH1.cxx:7689
 TH1.cxx:7690
 TH1.cxx:7691
 TH1.cxx:7692
 TH1.cxx:7693
 TH1.cxx:7694
 TH1.cxx:7695
 TH1.cxx:7696
 TH1.cxx:7697
 TH1.cxx:7698
 TH1.cxx:7699
 TH1.cxx:7700
 TH1.cxx:7701
 TH1.cxx:7702
 TH1.cxx:7703
 TH1.cxx:7704
 TH1.cxx:7705
 TH1.cxx:7706
 TH1.cxx:7707
 TH1.cxx:7708
 TH1.cxx:7709
 TH1.cxx:7710
 TH1.cxx:7711
 TH1.cxx:7712
 TH1.cxx:7713
 TH1.cxx:7714
 TH1.cxx:7715
 TH1.cxx:7716
 TH1.cxx:7717
 TH1.cxx:7718
 TH1.cxx:7719
 TH1.cxx:7720
 TH1.cxx:7721
 TH1.cxx:7722
 TH1.cxx:7723
 TH1.cxx:7724
 TH1.cxx:7725
 TH1.cxx:7726
 TH1.cxx:7727
 TH1.cxx:7728
 TH1.cxx:7729
 TH1.cxx:7730
 TH1.cxx:7731
 TH1.cxx:7732
 TH1.cxx:7733
 TH1.cxx:7734
 TH1.cxx:7735
 TH1.cxx:7736
 TH1.cxx:7737
 TH1.cxx:7738
 TH1.cxx:7739
 TH1.cxx:7740
 TH1.cxx:7741
 TH1.cxx:7742
 TH1.cxx:7743
 TH1.cxx:7744
 TH1.cxx:7745
 TH1.cxx:7746
 TH1.cxx:7747
 TH1.cxx:7748
 TH1.cxx:7749
 TH1.cxx:7750
 TH1.cxx:7751
 TH1.cxx:7752
 TH1.cxx:7753
 TH1.cxx:7754
 TH1.cxx:7755
 TH1.cxx:7756
 TH1.cxx:7757
 TH1.cxx:7758
 TH1.cxx:7759
 TH1.cxx:7760
 TH1.cxx:7761
 TH1.cxx:7762
 TH1.cxx:7763
 TH1.cxx:7764
 TH1.cxx:7765
 TH1.cxx:7766
 TH1.cxx:7767
 TH1.cxx:7768
 TH1.cxx:7769
 TH1.cxx:7770
 TH1.cxx:7771
 TH1.cxx:7772
 TH1.cxx:7773
 TH1.cxx:7774
 TH1.cxx:7775
 TH1.cxx:7776
 TH1.cxx:7777
 TH1.cxx:7778
 TH1.cxx:7779
 TH1.cxx:7780
 TH1.cxx:7781
 TH1.cxx:7782
 TH1.cxx:7783
 TH1.cxx:7784
 TH1.cxx:7785
 TH1.cxx:7786
 TH1.cxx:7787
 TH1.cxx:7788
 TH1.cxx:7789
 TH1.cxx:7790
 TH1.cxx:7791
 TH1.cxx:7792
 TH1.cxx:7793
 TH1.cxx:7794
 TH1.cxx:7795
 TH1.cxx:7796
 TH1.cxx:7797
 TH1.cxx:7798
 TH1.cxx:7799
 TH1.cxx:7800
 TH1.cxx:7801
 TH1.cxx:7802
 TH1.cxx:7803
 TH1.cxx:7804
 TH1.cxx:7805
 TH1.cxx:7806
 TH1.cxx:7807
 TH1.cxx:7808
 TH1.cxx:7809
 TH1.cxx:7810
 TH1.cxx:7811
 TH1.cxx:7812
 TH1.cxx:7813
 TH1.cxx:7814
 TH1.cxx:7815
 TH1.cxx:7816
 TH1.cxx:7817
 TH1.cxx:7818
 TH1.cxx:7819
 TH1.cxx:7820
 TH1.cxx:7821
 TH1.cxx:7822
 TH1.cxx:7823
 TH1.cxx:7824
 TH1.cxx:7825
 TH1.cxx:7826
 TH1.cxx:7827
 TH1.cxx:7828
 TH1.cxx:7829
 TH1.cxx:7830
 TH1.cxx:7831
 TH1.cxx:7832
 TH1.cxx:7833
 TH1.cxx:7834
 TH1.cxx:7835
 TH1.cxx:7836
 TH1.cxx:7837
 TH1.cxx:7838
 TH1.cxx:7839
 TH1.cxx:7840
 TH1.cxx:7841
 TH1.cxx:7842
 TH1.cxx:7843
 TH1.cxx:7844
 TH1.cxx:7845
 TH1.cxx:7846
 TH1.cxx:7847
 TH1.cxx:7848
 TH1.cxx:7849
 TH1.cxx:7850
 TH1.cxx:7851
 TH1.cxx:7852
 TH1.cxx:7853
 TH1.cxx:7854
 TH1.cxx:7855
 TH1.cxx:7856
 TH1.cxx:7857
 TH1.cxx:7858
 TH1.cxx:7859
 TH1.cxx:7860
 TH1.cxx:7861
 TH1.cxx:7862
 TH1.cxx:7863
 TH1.cxx:7864
 TH1.cxx:7865
 TH1.cxx:7866
 TH1.cxx:7867
 TH1.cxx:7868
 TH1.cxx:7869
 TH1.cxx:7870
 TH1.cxx:7871
 TH1.cxx:7872
 TH1.cxx:7873
 TH1.cxx:7874
 TH1.cxx:7875
 TH1.cxx:7876
 TH1.cxx:7877
 TH1.cxx:7878
 TH1.cxx:7879
 TH1.cxx:7880
 TH1.cxx:7881
 TH1.cxx:7882
 TH1.cxx:7883
 TH1.cxx:7884
 TH1.cxx:7885
 TH1.cxx:7886
 TH1.cxx:7887
 TH1.cxx:7888
 TH1.cxx:7889
 TH1.cxx:7890
 TH1.cxx:7891
 TH1.cxx:7892
 TH1.cxx:7893
 TH1.cxx:7894
 TH1.cxx:7895
 TH1.cxx:7896
 TH1.cxx:7897
 TH1.cxx:7898
 TH1.cxx:7899
 TH1.cxx:7900
 TH1.cxx:7901
 TH1.cxx:7902
 TH1.cxx:7903
 TH1.cxx:7904
 TH1.cxx:7905
 TH1.cxx:7906
 TH1.cxx:7907
 TH1.cxx:7908
 TH1.cxx:7909
 TH1.cxx:7910
 TH1.cxx:7911
 TH1.cxx:7912
 TH1.cxx:7913
 TH1.cxx:7914
 TH1.cxx:7915
 TH1.cxx:7916
 TH1.cxx:7917
 TH1.cxx:7918
 TH1.cxx:7919
 TH1.cxx:7920
 TH1.cxx:7921
 TH1.cxx:7922
 TH1.cxx:7923
 TH1.cxx:7924
 TH1.cxx:7925
 TH1.cxx:7926
 TH1.cxx:7927
 TH1.cxx:7928
 TH1.cxx:7929
 TH1.cxx:7930
 TH1.cxx:7931
 TH1.cxx:7932
 TH1.cxx:7933
 TH1.cxx:7934
 TH1.cxx:7935
 TH1.cxx:7936
 TH1.cxx:7937
 TH1.cxx:7938
 TH1.cxx:7939
 TH1.cxx:7940
 TH1.cxx:7941
 TH1.cxx:7942
 TH1.cxx:7943
 TH1.cxx:7944
 TH1.cxx:7945
 TH1.cxx:7946
 TH1.cxx:7947
 TH1.cxx:7948
 TH1.cxx:7949
 TH1.cxx:7950
 TH1.cxx:7951
 TH1.cxx:7952
 TH1.cxx:7953
 TH1.cxx:7954
 TH1.cxx:7955
 TH1.cxx:7956
 TH1.cxx:7957
 TH1.cxx:7958
 TH1.cxx:7959
 TH1.cxx:7960
 TH1.cxx:7961
 TH1.cxx:7962
 TH1.cxx:7963
 TH1.cxx:7964
 TH1.cxx:7965
 TH1.cxx:7966
 TH1.cxx:7967
 TH1.cxx:7968
 TH1.cxx:7969
 TH1.cxx:7970
 TH1.cxx:7971
 TH1.cxx:7972
 TH1.cxx:7973
 TH1.cxx:7974
 TH1.cxx:7975
 TH1.cxx:7976
 TH1.cxx:7977
 TH1.cxx:7978
 TH1.cxx:7979
 TH1.cxx:7980
 TH1.cxx:7981
 TH1.cxx:7982
 TH1.cxx:7983
 TH1.cxx:7984
 TH1.cxx:7985
 TH1.cxx:7986
 TH1.cxx:7987
 TH1.cxx:7988
 TH1.cxx:7989
 TH1.cxx:7990
 TH1.cxx:7991
 TH1.cxx:7992
 TH1.cxx:7993
 TH1.cxx:7994
 TH1.cxx:7995
 TH1.cxx:7996
 TH1.cxx:7997
 TH1.cxx:7998
 TH1.cxx:7999
 TH1.cxx:8000
 TH1.cxx:8001
 TH1.cxx:8002
 TH1.cxx:8003
 TH1.cxx:8004
 TH1.cxx:8005
 TH1.cxx:8006
 TH1.cxx:8007
 TH1.cxx:8008
 TH1.cxx:8009
 TH1.cxx:8010
 TH1.cxx:8011
 TH1.cxx:8012
 TH1.cxx:8013
 TH1.cxx:8014
 TH1.cxx:8015
 TH1.cxx:8016
 TH1.cxx:8017
 TH1.cxx:8018
 TH1.cxx:8019
 TH1.cxx:8020
 TH1.cxx:8021
 TH1.cxx:8022
 TH1.cxx:8023
 TH1.cxx:8024
 TH1.cxx:8025
 TH1.cxx:8026
 TH1.cxx:8027
 TH1.cxx:8028
 TH1.cxx:8029
 TH1.cxx:8030
 TH1.cxx:8031
 TH1.cxx:8032
 TH1.cxx:8033
 TH1.cxx:8034
 TH1.cxx:8035
 TH1.cxx:8036
 TH1.cxx:8037
 TH1.cxx:8038
 TH1.cxx:8039
 TH1.cxx:8040
 TH1.cxx:8041
 TH1.cxx:8042
 TH1.cxx:8043
 TH1.cxx:8044
 TH1.cxx:8045
 TH1.cxx:8046
 TH1.cxx:8047
 TH1.cxx:8048
 TH1.cxx:8049
 TH1.cxx:8050
 TH1.cxx:8051
 TH1.cxx:8052
 TH1.cxx:8053
 TH1.cxx:8054
 TH1.cxx:8055
 TH1.cxx:8056
 TH1.cxx:8057
 TH1.cxx:8058
 TH1.cxx:8059
 TH1.cxx:8060
 TH1.cxx:8061
 TH1.cxx:8062
 TH1.cxx:8063
 TH1.cxx:8064
 TH1.cxx:8065
 TH1.cxx:8066
 TH1.cxx:8067
 TH1.cxx:8068
 TH1.cxx:8069
 TH1.cxx:8070
 TH1.cxx:8071
 TH1.cxx:8072
 TH1.cxx:8073
 TH1.cxx:8074
 TH1.cxx:8075
 TH1.cxx:8076
 TH1.cxx:8077
 TH1.cxx:8078
 TH1.cxx:8079
 TH1.cxx:8080
 TH1.cxx:8081
 TH1.cxx:8082
 TH1.cxx:8083
 TH1.cxx:8084
 TH1.cxx:8085
 TH1.cxx:8086
 TH1.cxx:8087
 TH1.cxx:8088
 TH1.cxx:8089
 TH1.cxx:8090
 TH1.cxx:8091
 TH1.cxx:8092
 TH1.cxx:8093
 TH1.cxx:8094
 TH1.cxx:8095
 TH1.cxx:8096
 TH1.cxx:8097
 TH1.cxx:8098
 TH1.cxx:8099
 TH1.cxx:8100
 TH1.cxx:8101
 TH1.cxx:8102
 TH1.cxx:8103
 TH1.cxx:8104
 TH1.cxx:8105
 TH1.cxx:8106
 TH1.cxx:8107
 TH1.cxx:8108
 TH1.cxx:8109
 TH1.cxx:8110
 TH1.cxx:8111
 TH1.cxx:8112
 TH1.cxx:8113
 TH1.cxx:8114
 TH1.cxx:8115
 TH1.cxx:8116
 TH1.cxx:8117
 TH1.cxx:8118
 TH1.cxx:8119
 TH1.cxx:8120
 TH1.cxx:8121
 TH1.cxx:8122
 TH1.cxx:8123
 TH1.cxx:8124
 TH1.cxx:8125
 TH1.cxx:8126
 TH1.cxx:8127
 TH1.cxx:8128
 TH1.cxx:8129
 TH1.cxx:8130
 TH1.cxx:8131
 TH1.cxx:8132
 TH1.cxx:8133
 TH1.cxx:8134
 TH1.cxx:8135
 TH1.cxx:8136
 TH1.cxx:8137
 TH1.cxx:8138
 TH1.cxx:8139
 TH1.cxx:8140
 TH1.cxx:8141
 TH1.cxx:8142
 TH1.cxx:8143
 TH1.cxx:8144
 TH1.cxx:8145
 TH1.cxx:8146
 TH1.cxx:8147
 TH1.cxx:8148
 TH1.cxx:8149
 TH1.cxx:8150
 TH1.cxx:8151
 TH1.cxx:8152
 TH1.cxx:8153
 TH1.cxx:8154
 TH1.cxx:8155
 TH1.cxx:8156
 TH1.cxx:8157
 TH1.cxx:8158
 TH1.cxx:8159
 TH1.cxx:8160
 TH1.cxx:8161
 TH1.cxx:8162
 TH1.cxx:8163
 TH1.cxx:8164
 TH1.cxx:8165
 TH1.cxx:8166
 TH1.cxx:8167
 TH1.cxx:8168
 TH1.cxx:8169
 TH1.cxx:8170
 TH1.cxx:8171
 TH1.cxx:8172
 TH1.cxx:8173
 TH1.cxx:8174
 TH1.cxx:8175
 TH1.cxx:8176
 TH1.cxx:8177
 TH1.cxx:8178
 TH1.cxx:8179
 TH1.cxx:8180
 TH1.cxx:8181
 TH1.cxx:8182
 TH1.cxx:8183
 TH1.cxx:8184
 TH1.cxx:8185
 TH1.cxx:8186
 TH1.cxx:8187
 TH1.cxx:8188
 TH1.cxx:8189
 TH1.cxx:8190
 TH1.cxx:8191
 TH1.cxx:8192
 TH1.cxx:8193
 TH1.cxx:8194
 TH1.cxx:8195
 TH1.cxx:8196
 TH1.cxx:8197
 TH1.cxx:8198
 TH1.cxx:8199
 TH1.cxx:8200
 TH1.cxx:8201
 TH1.cxx:8202
 TH1.cxx:8203
 TH1.cxx:8204
 TH1.cxx:8205
 TH1.cxx:8206
 TH1.cxx:8207
 TH1.cxx:8208
 TH1.cxx:8209
 TH1.cxx:8210
 TH1.cxx:8211
 TH1.cxx:8212
 TH1.cxx:8213
 TH1.cxx:8214
 TH1.cxx:8215
 TH1.cxx:8216
 TH1.cxx:8217
 TH1.cxx:8218
 TH1.cxx:8219
 TH1.cxx:8220
 TH1.cxx:8221
 TH1.cxx:8222
 TH1.cxx:8223
 TH1.cxx:8224
 TH1.cxx:8225
 TH1.cxx:8226
 TH1.cxx:8227
 TH1.cxx:8228
 TH1.cxx:8229
 TH1.cxx:8230
 TH1.cxx:8231
 TH1.cxx:8232
 TH1.cxx:8233
 TH1.cxx:8234
 TH1.cxx:8235
 TH1.cxx:8236
 TH1.cxx:8237
 TH1.cxx:8238
 TH1.cxx:8239
 TH1.cxx:8240
 TH1.cxx:8241
 TH1.cxx:8242
 TH1.cxx:8243
 TH1.cxx:8244
 TH1.cxx:8245
 TH1.cxx:8246
 TH1.cxx:8247
 TH1.cxx:8248
 TH1.cxx:8249
 TH1.cxx:8250
 TH1.cxx:8251
 TH1.cxx:8252
 TH1.cxx:8253
 TH1.cxx:8254
 TH1.cxx:8255
 TH1.cxx:8256
 TH1.cxx:8257
 TH1.cxx:8258
 TH1.cxx:8259
 TH1.cxx:8260
 TH1.cxx:8261
 TH1.cxx:8262
 TH1.cxx:8263
 TH1.cxx:8264
 TH1.cxx:8265
 TH1.cxx:8266
 TH1.cxx:8267
 TH1.cxx:8268
 TH1.cxx:8269
 TH1.cxx:8270
 TH1.cxx:8271
 TH1.cxx:8272
 TH1.cxx:8273
 TH1.cxx:8274
 TH1.cxx:8275
 TH1.cxx:8276
 TH1.cxx:8277
 TH1.cxx:8278
 TH1.cxx:8279
 TH1.cxx:8280
 TH1.cxx:8281
 TH1.cxx:8282
 TH1.cxx:8283
 TH1.cxx:8284
 TH1.cxx:8285
 TH1.cxx:8286
 TH1.cxx:8287
 TH1.cxx:8288
 TH1.cxx:8289
 TH1.cxx:8290
 TH1.cxx:8291
 TH1.cxx:8292
 TH1.cxx:8293
 TH1.cxx:8294
 TH1.cxx:8295
 TH1.cxx:8296
 TH1.cxx:8297
 TH1.cxx:8298
 TH1.cxx:8299
 TH1.cxx:8300
 TH1.cxx:8301
 TH1.cxx:8302
 TH1.cxx:8303
 TH1.cxx:8304
 TH1.cxx:8305
 TH1.cxx:8306
 TH1.cxx:8307
 TH1.cxx:8308
 TH1.cxx:8309
 TH1.cxx:8310
 TH1.cxx:8311
 TH1.cxx:8312
 TH1.cxx:8313
 TH1.cxx:8314
 TH1.cxx:8315
 TH1.cxx:8316
 TH1.cxx:8317
 TH1.cxx:8318
 TH1.cxx:8319
 TH1.cxx:8320
 TH1.cxx:8321
 TH1.cxx:8322
 TH1.cxx:8323
 TH1.cxx:8324
 TH1.cxx:8325
 TH1.cxx:8326
 TH1.cxx:8327
 TH1.cxx:8328
 TH1.cxx:8329
 TH1.cxx:8330
 TH1.cxx:8331
 TH1.cxx:8332
 TH1.cxx:8333
 TH1.cxx:8334
 TH1.cxx:8335
 TH1.cxx:8336
 TH1.cxx:8337
 TH1.cxx:8338
 TH1.cxx:8339
 TH1.cxx:8340
 TH1.cxx:8341
 TH1.cxx:8342
 TH1.cxx:8343
 TH1.cxx:8344
 TH1.cxx:8345
 TH1.cxx:8346
 TH1.cxx:8347
 TH1.cxx:8348
 TH1.cxx:8349
 TH1.cxx:8350
 TH1.cxx:8351
 TH1.cxx:8352
 TH1.cxx:8353
 TH1.cxx:8354
 TH1.cxx:8355
 TH1.cxx:8356
 TH1.cxx:8357
 TH1.cxx:8358
 TH1.cxx:8359
 TH1.cxx:8360
 TH1.cxx:8361
 TH1.cxx:8362
 TH1.cxx:8363
 TH1.cxx:8364
 TH1.cxx:8365
 TH1.cxx:8366
 TH1.cxx:8367
 TH1.cxx:8368
 TH1.cxx:8369
 TH1.cxx:8370
 TH1.cxx:8371
 TH1.cxx:8372
 TH1.cxx:8373
 TH1.cxx:8374
 TH1.cxx:8375
 TH1.cxx:8376
 TH1.cxx:8377
 TH1.cxx:8378
 TH1.cxx:8379
 TH1.cxx:8380
 TH1.cxx:8381
 TH1.cxx:8382
 TH1.cxx:8383
 TH1.cxx:8384
 TH1.cxx:8385
 TH1.cxx:8386
 TH1.cxx:8387
 TH1.cxx:8388
 TH1.cxx:8389
 TH1.cxx:8390
 TH1.cxx:8391
 TH1.cxx:8392
 TH1.cxx:8393
 TH1.cxx:8394
 TH1.cxx:8395
 TH1.cxx:8396
 TH1.cxx:8397
 TH1.cxx:8398
 TH1.cxx:8399
 TH1.cxx:8400
 TH1.cxx:8401
 TH1.cxx:8402
 TH1.cxx:8403
 TH1.cxx:8404
 TH1.cxx:8405
 TH1.cxx:8406
 TH1.cxx:8407
 TH1.cxx:8408
 TH1.cxx:8409
 TH1.cxx:8410
 TH1.cxx:8411
 TH1.cxx:8412
 TH1.cxx:8413
 TH1.cxx:8414
 TH1.cxx:8415
 TH1.cxx:8416
 TH1.cxx:8417
 TH1.cxx:8418
 TH1.cxx:8419
 TH1.cxx:8420
 TH1.cxx:8421
 TH1.cxx:8422
 TH1.cxx:8423
 TH1.cxx:8424
 TH1.cxx:8425
 TH1.cxx:8426
 TH1.cxx:8427
 TH1.cxx:8428
 TH1.cxx:8429
 TH1.cxx:8430
 TH1.cxx:8431
 TH1.cxx:8432
 TH1.cxx:8433
 TH1.cxx:8434
 TH1.cxx:8435
 TH1.cxx:8436
 TH1.cxx:8437
 TH1.cxx:8438
 TH1.cxx:8439
 TH1.cxx:8440
 TH1.cxx:8441
 TH1.cxx:8442
 TH1.cxx:8443
 TH1.cxx:8444
 TH1.cxx:8445
 TH1.cxx:8446
 TH1.cxx:8447
 TH1.cxx:8448
 TH1.cxx:8449
 TH1.cxx:8450
 TH1.cxx:8451
 TH1.cxx:8452
 TH1.cxx:8453
 TH1.cxx:8454
 TH1.cxx:8455
 TH1.cxx:8456
 TH1.cxx:8457
 TH1.cxx:8458
 TH1.cxx:8459
 TH1.cxx:8460
 TH1.cxx:8461
 TH1.cxx:8462
 TH1.cxx:8463
 TH1.cxx:8464
 TH1.cxx:8465
 TH1.cxx:8466
 TH1.cxx:8467
 TH1.cxx:8468
 TH1.cxx:8469
 TH1.cxx:8470
 TH1.cxx:8471
 TH1.cxx:8472
 TH1.cxx:8473
 TH1.cxx:8474
 TH1.cxx:8475
 TH1.cxx:8476
 TH1.cxx:8477
 TH1.cxx:8478
 TH1.cxx:8479
 TH1.cxx:8480
 TH1.cxx:8481
 TH1.cxx:8482
 TH1.cxx:8483
 TH1.cxx:8484
 TH1.cxx:8485
 TH1.cxx:8486
 TH1.cxx:8487
 TH1.cxx:8488
 TH1.cxx:8489
 TH1.cxx:8490
 TH1.cxx:8491
 TH1.cxx:8492
 TH1.cxx:8493
 TH1.cxx:8494
 TH1.cxx:8495
 TH1.cxx:8496
 TH1.cxx:8497
 TH1.cxx:8498
 TH1.cxx:8499
 TH1.cxx:8500
 TH1.cxx:8501
 TH1.cxx:8502
 TH1.cxx:8503
 TH1.cxx:8504
 TH1.cxx:8505
 TH1.cxx:8506
 TH1.cxx:8507
 TH1.cxx:8508
 TH1.cxx:8509
 TH1.cxx:8510
 TH1.cxx:8511
 TH1.cxx:8512
 TH1.cxx:8513
 TH1.cxx:8514
 TH1.cxx:8515
 TH1.cxx:8516
 TH1.cxx:8517
 TH1.cxx:8518
 TH1.cxx:8519
 TH1.cxx:8520
 TH1.cxx:8521
 TH1.cxx:8522
 TH1.cxx:8523
 TH1.cxx:8524
 TH1.cxx:8525
 TH1.cxx:8526
 TH1.cxx:8527
 TH1.cxx:8528
 TH1.cxx:8529
 TH1.cxx:8530
 TH1.cxx:8531
 TH1.cxx:8532
 TH1.cxx:8533
 TH1.cxx:8534
 TH1.cxx:8535
 TH1.cxx:8536
 TH1.cxx:8537
 TH1.cxx:8538
 TH1.cxx:8539
 TH1.cxx:8540
 TH1.cxx:8541
 TH1.cxx:8542
 TH1.cxx:8543
 TH1.cxx:8544
 TH1.cxx:8545
 TH1.cxx:8546
 TH1.cxx:8547
 TH1.cxx:8548
 TH1.cxx:8549
 TH1.cxx:8550
 TH1.cxx:8551
 TH1.cxx:8552
 TH1.cxx:8553
 TH1.cxx:8554
 TH1.cxx:8555
 TH1.cxx:8556
 TH1.cxx:8557
 TH1.cxx:8558
 TH1.cxx:8559
 TH1.cxx:8560
 TH1.cxx:8561
 TH1.cxx:8562
 TH1.cxx:8563
 TH1.cxx:8564
 TH1.cxx:8565
 TH1.cxx:8566
 TH1.cxx:8567
 TH1.cxx:8568
 TH1.cxx:8569
 TH1.cxx:8570
 TH1.cxx:8571
 TH1.cxx:8572
 TH1.cxx:8573
 TH1.cxx:8574
 TH1.cxx:8575
 TH1.cxx:8576
 TH1.cxx:8577
 TH1.cxx:8578
 TH1.cxx:8579
 TH1.cxx:8580
 TH1.cxx:8581
 TH1.cxx:8582
 TH1.cxx:8583
 TH1.cxx:8584
 TH1.cxx:8585
 TH1.cxx:8586
 TH1.cxx:8587
 TH1.cxx:8588
 TH1.cxx:8589
 TH1.cxx:8590
 TH1.cxx:8591
 TH1.cxx:8592
 TH1.cxx:8593
 TH1.cxx:8594
 TH1.cxx:8595
 TH1.cxx:8596
 TH1.cxx:8597
 TH1.cxx:8598
 TH1.cxx:8599
 TH1.cxx:8600
 TH1.cxx:8601
 TH1.cxx:8602
 TH1.cxx:8603
 TH1.cxx:8604
 TH1.cxx:8605
 TH1.cxx:8606
 TH1.cxx:8607
 TH1.cxx:8608
 TH1.cxx:8609
 TH1.cxx:8610
 TH1.cxx:8611
 TH1.cxx:8612
 TH1.cxx:8613
 TH1.cxx:8614
 TH1.cxx:8615
 TH1.cxx:8616
 TH1.cxx:8617
 TH1.cxx:8618
 TH1.cxx:8619
 TH1.cxx:8620
 TH1.cxx:8621
 TH1.cxx:8622
 TH1.cxx:8623
 TH1.cxx:8624
 TH1.cxx:8625
 TH1.cxx:8626
 TH1.cxx:8627
 TH1.cxx:8628
 TH1.cxx:8629
 TH1.cxx:8630
 TH1.cxx:8631
 TH1.cxx:8632
 TH1.cxx:8633
 TH1.cxx:8634
 TH1.cxx:8635
 TH1.cxx:8636
 TH1.cxx:8637
 TH1.cxx:8638
 TH1.cxx:8639
 TH1.cxx:8640
 TH1.cxx:8641
 TH1.cxx:8642
 TH1.cxx:8643
 TH1.cxx:8644
 TH1.cxx:8645
 TH1.cxx:8646
 TH1.cxx:8647
 TH1.cxx:8648
 TH1.cxx:8649
 TH1.cxx:8650
 TH1.cxx:8651
 TH1.cxx:8652
 TH1.cxx:8653
 TH1.cxx:8654
 TH1.cxx:8655
 TH1.cxx:8656
 TH1.cxx:8657
 TH1.cxx:8658
 TH1.cxx:8659
 TH1.cxx:8660
 TH1.cxx:8661
 TH1.cxx:8662
 TH1.cxx:8663
 TH1.cxx:8664
 TH1.cxx:8665
 TH1.cxx:8666
 TH1.cxx:8667
 TH1.cxx:8668
 TH1.cxx:8669
 TH1.cxx:8670
 TH1.cxx:8671
 TH1.cxx:8672
 TH1.cxx:8673
 TH1.cxx:8674
 TH1.cxx:8675
 TH1.cxx:8676
 TH1.cxx:8677
 TH1.cxx:8678
 TH1.cxx:8679
 TH1.cxx:8680
 TH1.cxx:8681
 TH1.cxx:8682
 TH1.cxx:8683
 TH1.cxx:8684
 TH1.cxx:8685
 TH1.cxx:8686
 TH1.cxx:8687
 TH1.cxx:8688
 TH1.cxx:8689
 TH1.cxx:8690
 TH1.cxx:8691
 TH1.cxx:8692
 TH1.cxx:8693
 TH1.cxx:8694
 TH1.cxx:8695
 TH1.cxx:8696
 TH1.cxx:8697
 TH1.cxx:8698
 TH1.cxx:8699
 TH1.cxx:8700
 TH1.cxx:8701
 TH1.cxx:8702
 TH1.cxx:8703
 TH1.cxx:8704
 TH1.cxx:8705
 TH1.cxx:8706
 TH1.cxx:8707
 TH1.cxx:8708
 TH1.cxx:8709
 TH1.cxx:8710
 TH1.cxx:8711
 TH1.cxx:8712
 TH1.cxx:8713
 TH1.cxx:8714
 TH1.cxx:8715
 TH1.cxx:8716
 TH1.cxx:8717
 TH1.cxx:8718
 TH1.cxx:8719
 TH1.cxx:8720
 TH1.cxx:8721
 TH1.cxx:8722
 TH1.cxx:8723
 TH1.cxx:8724
 TH1.cxx:8725
 TH1.cxx:8726
 TH1.cxx:8727
 TH1.cxx:8728
 TH1.cxx:8729
 TH1.cxx:8730
 TH1.cxx:8731
 TH1.cxx:8732
 TH1.cxx:8733
 TH1.cxx:8734
 TH1.cxx:8735
 TH1.cxx:8736
 TH1.cxx:8737
 TH1.cxx:8738
 TH1.cxx:8739
 TH1.cxx:8740
 TH1.cxx:8741
 TH1.cxx:8742
 TH1.cxx:8743
 TH1.cxx:8744
 TH1.cxx:8745
 TH1.cxx:8746
 TH1.cxx:8747
 TH1.cxx:8748
 TH1.cxx:8749
 TH1.cxx:8750
 TH1.cxx:8751
 TH1.cxx:8752
 TH1.cxx:8753
 TH1.cxx:8754
 TH1.cxx:8755
 TH1.cxx:8756
 TH1.cxx:8757
 TH1.cxx:8758
 TH1.cxx:8759
 TH1.cxx:8760
 TH1.cxx:8761
 TH1.cxx:8762
 TH1.cxx:8763
 TH1.cxx:8764
 TH1.cxx:8765
 TH1.cxx:8766
 TH1.cxx:8767
 TH1.cxx:8768
 TH1.cxx:8769
 TH1.cxx:8770
 TH1.cxx:8771
 TH1.cxx:8772
 TH1.cxx:8773
 TH1.cxx:8774
 TH1.cxx:8775
 TH1.cxx:8776
 TH1.cxx:8777
 TH1.cxx:8778
 TH1.cxx:8779
 TH1.cxx:8780
 TH1.cxx:8781
 TH1.cxx:8782
 TH1.cxx:8783
 TH1.cxx:8784
 TH1.cxx:8785
 TH1.cxx:8786
 TH1.cxx:8787
 TH1.cxx:8788
 TH1.cxx:8789
 TH1.cxx:8790
 TH1.cxx:8791
 TH1.cxx:8792
 TH1.cxx:8793
 TH1.cxx:8794
 TH1.cxx:8795
 TH1.cxx:8796
 TH1.cxx:8797
 TH1.cxx:8798
 TH1.cxx:8799
 TH1.cxx:8800
 TH1.cxx:8801
 TH1.cxx:8802
 TH1.cxx:8803
 TH1.cxx:8804
 TH1.cxx:8805
 TH1.cxx:8806
 TH1.cxx:8807
 TH1.cxx:8808
 TH1.cxx:8809
 TH1.cxx:8810
 TH1.cxx:8811
 TH1.cxx:8812
 TH1.cxx:8813
 TH1.cxx:8814
 TH1.cxx:8815
 TH1.cxx:8816
 TH1.cxx:8817
 TH1.cxx:8818
 TH1.cxx:8819
 TH1.cxx:8820
 TH1.cxx:8821
 TH1.cxx:8822
 TH1.cxx:8823
 TH1.cxx:8824
 TH1.cxx:8825
 TH1.cxx:8826
 TH1.cxx:8827
 TH1.cxx:8828
 TH1.cxx:8829
 TH1.cxx:8830
 TH1.cxx:8831
 TH1.cxx:8832
 TH1.cxx:8833
 TH1.cxx:8834
 TH1.cxx:8835
 TH1.cxx:8836
 TH1.cxx:8837
 TH1.cxx:8838
 TH1.cxx:8839
 TH1.cxx:8840
 TH1.cxx:8841
 TH1.cxx:8842
 TH1.cxx:8843
 TH1.cxx:8844
 TH1.cxx:8845
 TH1.cxx:8846
 TH1.cxx:8847
 TH1.cxx:8848
 TH1.cxx:8849
 TH1.cxx:8850
 TH1.cxx:8851
 TH1.cxx:8852
 TH1.cxx:8853
 TH1.cxx:8854
 TH1.cxx:8855
 TH1.cxx:8856
 TH1.cxx:8857
 TH1.cxx:8858
 TH1.cxx:8859
 TH1.cxx:8860
 TH1.cxx:8861
 TH1.cxx:8862
 TH1.cxx:8863
 TH1.cxx:8864
 TH1.cxx:8865
 TH1.cxx:8866
 TH1.cxx:8867
 TH1.cxx:8868
 TH1.cxx:8869
 TH1.cxx:8870
 TH1.cxx:8871
 TH1.cxx:8872
 TH1.cxx:8873
 TH1.cxx:8874
 TH1.cxx:8875
 TH1.cxx:8876
 TH1.cxx:8877
 TH1.cxx:8878
 TH1.cxx:8879
 TH1.cxx:8880
 TH1.cxx:8881
 TH1.cxx:8882
 TH1.cxx:8883
 TH1.cxx:8884
 TH1.cxx:8885
 TH1.cxx:8886
 TH1.cxx:8887
 TH1.cxx:8888
 TH1.cxx:8889
 TH1.cxx:8890
 TH1.cxx:8891
 TH1.cxx:8892
 TH1.cxx:8893
 TH1.cxx:8894
 TH1.cxx:8895
 TH1.cxx:8896
 TH1.cxx:8897
 TH1.cxx:8898
 TH1.cxx:8899
 TH1.cxx:8900
 TH1.cxx:8901
 TH1.cxx:8902
 TH1.cxx:8903
 TH1.cxx:8904
 TH1.cxx:8905
 TH1.cxx:8906
 TH1.cxx:8907
 TH1.cxx:8908
 TH1.cxx:8909
 TH1.cxx:8910
 TH1.cxx:8911
 TH1.cxx:8912
 TH1.cxx:8913
 TH1.cxx:8914
 TH1.cxx:8915
 TH1.cxx:8916
 TH1.cxx:8917
 TH1.cxx:8918
 TH1.cxx:8919
 TH1.cxx:8920
 TH1.cxx:8921
 TH1.cxx:8922
 TH1.cxx:8923
 TH1.cxx:8924
 TH1.cxx:8925
 TH1.cxx:8926
 TH1.cxx:8927
 TH1.cxx:8928
 TH1.cxx:8929
 TH1.cxx:8930
 TH1.cxx:8931
 TH1.cxx:8932
 TH1.cxx:8933
 TH1.cxx:8934
 TH1.cxx:8935
 TH1.cxx:8936
 TH1.cxx:8937
 TH1.cxx:8938
 TH1.cxx:8939
 TH1.cxx:8940
 TH1.cxx:8941
 TH1.cxx:8942
 TH1.cxx:8943
 TH1.cxx:8944
 TH1.cxx:8945
 TH1.cxx:8946
 TH1.cxx:8947
 TH1.cxx:8948
 TH1.cxx:8949
 TH1.cxx:8950
 TH1.cxx:8951
 TH1.cxx:8952
 TH1.cxx:8953
 TH1.cxx:8954
 TH1.cxx:8955
 TH1.cxx:8956
 TH1.cxx:8957
 TH1.cxx:8958
 TH1.cxx:8959
 TH1.cxx:8960
 TH1.cxx:8961
 TH1.cxx:8962
 TH1.cxx:8963
 TH1.cxx:8964
 TH1.cxx:8965
 TH1.cxx:8966
 TH1.cxx:8967
 TH1.cxx:8968
 TH1.cxx:8969
 TH1.cxx:8970
 TH1.cxx:8971
 TH1.cxx:8972
 TH1.cxx:8973
 TH1.cxx:8974
 TH1.cxx:8975
 TH1.cxx:8976
 TH1.cxx:8977
 TH1.cxx:8978
 TH1.cxx:8979
 TH1.cxx:8980
 TH1.cxx:8981
 TH1.cxx:8982
 TH1.cxx:8983
 TH1.cxx:8984
 TH1.cxx:8985
 TH1.cxx:8986
 TH1.cxx:8987
 TH1.cxx:8988
 TH1.cxx:8989
 TH1.cxx:8990
 TH1.cxx:8991
 TH1.cxx:8992
 TH1.cxx:8993
 TH1.cxx:8994
 TH1.cxx:8995
 TH1.cxx:8996
 TH1.cxx:8997
 TH1.cxx:8998
 TH1.cxx:8999
 TH1.cxx:9000
 TH1.cxx:9001
 TH1.cxx:9002
 TH1.cxx:9003
 TH1.cxx:9004
 TH1.cxx:9005
 TH1.cxx:9006
 TH1.cxx:9007
 TH1.cxx:9008
 TH1.cxx:9009
 TH1.cxx:9010
 TH1.cxx:9011
 TH1.cxx:9012
 TH1.cxx:9013
 TH1.cxx:9014
 TH1.cxx:9015
 TH1.cxx:9016
 TH1.cxx:9017
 TH1.cxx:9018
 TH1.cxx:9019
 TH1.cxx:9020
 TH1.cxx:9021
 TH1.cxx:9022
 TH1.cxx:9023
 TH1.cxx:9024
 TH1.cxx:9025
 TH1.cxx:9026
 TH1.cxx:9027
 TH1.cxx:9028
 TH1.cxx:9029
 TH1.cxx:9030
 TH1.cxx:9031
 TH1.cxx:9032
 TH1.cxx:9033
 TH1.cxx:9034
 TH1.cxx:9035
 TH1.cxx:9036
 TH1.cxx:9037
 TH1.cxx:9038
 TH1.cxx:9039
 TH1.cxx:9040
 TH1.cxx:9041
 TH1.cxx:9042
 TH1.cxx:9043
 TH1.cxx:9044
 TH1.cxx:9045
 TH1.cxx:9046
 TH1.cxx:9047
 TH1.cxx:9048
 TH1.cxx:9049
 TH1.cxx:9050
 TH1.cxx:9051
 TH1.cxx:9052
 TH1.cxx:9053
 TH1.cxx:9054
 TH1.cxx:9055
 TH1.cxx:9056
 TH1.cxx:9057
 TH1.cxx:9058
 TH1.cxx:9059
 TH1.cxx:9060
 TH1.cxx:9061
 TH1.cxx:9062
 TH1.cxx:9063
 TH1.cxx:9064
 TH1.cxx:9065
 TH1.cxx:9066
 TH1.cxx:9067
 TH1.cxx:9068
 TH1.cxx:9069
 TH1.cxx:9070
 TH1.cxx:9071
 TH1.cxx:9072
 TH1.cxx:9073
 TH1.cxx:9074
 TH1.cxx:9075
 TH1.cxx:9076
 TH1.cxx:9077
 TH1.cxx:9078
 TH1.cxx:9079
 TH1.cxx:9080
 TH1.cxx:9081
 TH1.cxx:9082
 TH1.cxx:9083
 TH1.cxx:9084
 TH1.cxx:9085
 TH1.cxx:9086
 TH1.cxx:9087
 TH1.cxx:9088
 TH1.cxx:9089
 TH1.cxx:9090
 TH1.cxx:9091
 TH1.cxx:9092
 TH1.cxx:9093
 TH1.cxx:9094
 TH1.cxx:9095
 TH1.cxx:9096
 TH1.cxx:9097
 TH1.cxx:9098
 TH1.cxx:9099
 TH1.cxx:9100
 TH1.cxx:9101
 TH1.cxx:9102
 TH1.cxx:9103
 TH1.cxx:9104
 TH1.cxx:9105
 TH1.cxx:9106
 TH1.cxx:9107
 TH1.cxx:9108
 TH1.cxx:9109
 TH1.cxx:9110
 TH1.cxx:9111
 TH1.cxx:9112
 TH1.cxx:9113
 TH1.cxx:9114
 TH1.cxx:9115
 TH1.cxx:9116
 TH1.cxx:9117
 TH1.cxx:9118
 TH1.cxx:9119
 TH1.cxx:9120
 TH1.cxx:9121
 TH1.cxx:9122
 TH1.cxx:9123
 TH1.cxx:9124
 TH1.cxx:9125
 TH1.cxx:9126
 TH1.cxx:9127
 TH1.cxx:9128
 TH1.cxx:9129
 TH1.cxx:9130
 TH1.cxx:9131
 TH1.cxx:9132
 TH1.cxx:9133
 TH1.cxx:9134
 TH1.cxx:9135
 TH1.cxx:9136
 TH1.cxx:9137
 TH1.cxx:9138
 TH1.cxx:9139
 TH1.cxx:9140
 TH1.cxx:9141
 TH1.cxx:9142
 TH1.cxx:9143
 TH1.cxx:9144
 TH1.cxx:9145
 TH1.cxx:9146
 TH1.cxx:9147
 TH1.cxx:9148
 TH1.cxx:9149
 TH1.cxx:9150
 TH1.cxx:9151
 TH1.cxx:9152
 TH1.cxx:9153
 TH1.cxx:9154
 TH1.cxx:9155
 TH1.cxx:9156
 TH1.cxx:9157
 TH1.cxx:9158
 TH1.cxx:9159
 TH1.cxx:9160
 TH1.cxx:9161
 TH1.cxx:9162
 TH1.cxx:9163
 TH1.cxx:9164
 TH1.cxx:9165
 TH1.cxx:9166
 TH1.cxx:9167
 TH1.cxx:9168
 TH1.cxx:9169
 TH1.cxx:9170
 TH1.cxx:9171
 TH1.cxx:9172
 TH1.cxx:9173
 TH1.cxx:9174
 TH1.cxx:9175
 TH1.cxx:9176
 TH1.cxx:9177
 TH1.cxx:9178
 TH1.cxx:9179
 TH1.cxx:9180
 TH1.cxx:9181
 TH1.cxx:9182
 TH1.cxx:9183
 TH1.cxx:9184
 TH1.cxx:9185
 TH1.cxx:9186
 TH1.cxx:9187
 TH1.cxx:9188
 TH1.cxx:9189
 TH1.cxx:9190
 TH1.cxx:9191
 TH1.cxx:9192
 TH1.cxx:9193
 TH1.cxx:9194
 TH1.cxx:9195
 TH1.cxx:9196
 TH1.cxx:9197
 TH1.cxx:9198
 TH1.cxx:9199
 TH1.cxx:9200
 TH1.cxx:9201
 TH1.cxx:9202
 TH1.cxx:9203
 TH1.cxx:9204
 TH1.cxx:9205
 TH1.cxx:9206
 TH1.cxx:9207
 TH1.cxx:9208
 TH1.cxx:9209
 TH1.cxx:9210
 TH1.cxx:9211
 TH1.cxx:9212
 TH1.cxx:9213
 TH1.cxx:9214
 TH1.cxx:9215
 TH1.cxx:9216
 TH1.cxx:9217
 TH1.cxx:9218
 TH1.cxx:9219
 TH1.cxx:9220
 TH1.cxx:9221
 TH1.cxx:9222
 TH1.cxx:9223
 TH1.cxx:9224
 TH1.cxx:9225
 TH1.cxx:9226
 TH1.cxx:9227
 TH1.cxx:9228
 TH1.cxx:9229
 TH1.cxx:9230
 TH1.cxx:9231
 TH1.cxx:9232
 TH1.cxx:9233
 TH1.cxx:9234
 TH1.cxx:9235
 TH1.cxx:9236
 TH1.cxx:9237
 TH1.cxx:9238
 TH1.cxx:9239
 TH1.cxx:9240
 TH1.cxx:9241
 TH1.cxx:9242
 TH1.cxx:9243
 TH1.cxx:9244
 TH1.cxx:9245
 TH1.cxx:9246
 TH1.cxx:9247
 TH1.cxx:9248
 TH1.cxx:9249
 TH1.cxx:9250
 TH1.cxx:9251
 TH1.cxx:9252
 TH1.cxx:9253
 TH1.cxx:9254
 TH1.cxx:9255
 TH1.cxx:9256
 TH1.cxx:9257
 TH1.cxx:9258
 TH1.cxx:9259
 TH1.cxx:9260
 TH1.cxx:9261
 TH1.cxx:9262
 TH1.cxx:9263
 TH1.cxx:9264
 TH1.cxx:9265
 TH1.cxx:9266
 TH1.cxx:9267
 TH1.cxx:9268
 TH1.cxx:9269
 TH1.cxx:9270
 TH1.cxx:9271
 TH1.cxx:9272
 TH1.cxx:9273
 TH1.cxx:9274
 TH1.cxx:9275
 TH1.cxx:9276
 TH1.cxx:9277
 TH1.cxx:9278
 TH1.cxx:9279
 TH1.cxx:9280
 TH1.cxx:9281
 TH1.cxx:9282
 TH1.cxx:9283
 TH1.cxx:9284
 TH1.cxx:9285
 TH1.cxx:9286
 TH1.cxx:9287
 TH1.cxx:9288
 TH1.cxx:9289
 TH1.cxx:9290
 TH1.cxx:9291
 TH1.cxx:9292
 TH1.cxx:9293
 TH1.cxx:9294
 TH1.cxx:9295
 TH1.cxx:9296
 TH1.cxx:9297
 TH1.cxx:9298
 TH1.cxx:9299
 TH1.cxx:9300
 TH1.cxx:9301
 TH1.cxx:9302
 TH1.cxx:9303
 TH1.cxx:9304
 TH1.cxx:9305
 TH1.cxx:9306
 TH1.cxx:9307
 TH1.cxx:9308
 TH1.cxx:9309
 TH1.cxx:9310
 TH1.cxx:9311
 TH1.cxx:9312
 TH1.cxx:9313
 TH1.cxx:9314
 TH1.cxx:9315
 TH1.cxx:9316
 TH1.cxx:9317
 TH1.cxx:9318
 TH1.cxx:9319
 TH1.cxx:9320
 TH1.cxx:9321
 TH1.cxx:9322
 TH1.cxx:9323
 TH1.cxx:9324
 TH1.cxx:9325
 TH1.cxx:9326
 TH1.cxx:9327
 TH1.cxx:9328
 TH1.cxx:9329
 TH1.cxx:9330
 TH1.cxx:9331
 TH1.cxx:9332
 TH1.cxx:9333
 TH1.cxx:9334
 TH1.cxx:9335
 TH1.cxx:9336
 TH1.cxx:9337
 TH1.cxx:9338
 TH1.cxx:9339
 TH1.cxx:9340
 TH1.cxx:9341
 TH1.cxx:9342
 TH1.cxx:9343
 TH1.cxx:9344
 TH1.cxx:9345
 TH1.cxx:9346
 TH1.cxx:9347
 TH1.cxx:9348
 TH1.cxx:9349
 TH1.cxx:9350
 TH1.cxx:9351
 TH1.cxx:9352
 TH1.cxx:9353
 TH1.cxx:9354
 TH1.cxx:9355
 TH1.cxx:9356
 TH1.cxx:9357
 TH1.cxx:9358
 TH1.cxx:9359
 TH1.cxx:9360
 TH1.cxx:9361
 TH1.cxx:9362
 TH1.cxx:9363
 TH1.cxx:9364
 TH1.cxx:9365
 TH1.cxx:9366
 TH1.cxx:9367
 TH1.cxx:9368
 TH1.cxx:9369
 TH1.cxx:9370
 TH1.cxx:9371
 TH1.cxx:9372
 TH1.cxx:9373
 TH1.cxx:9374
 TH1.cxx:9375
 TH1.cxx:9376
 TH1.cxx:9377
 TH1.cxx:9378
 TH1.cxx:9379
 TH1.cxx:9380
 TH1.cxx:9381
 TH1.cxx:9382
 TH1.cxx:9383
 TH1.cxx:9384
 TH1.cxx:9385
 TH1.cxx:9386
 TH1.cxx:9387
 TH1.cxx:9388
 TH1.cxx:9389
 TH1.cxx:9390
 TH1.cxx:9391
 TH1.cxx:9392
 TH1.cxx:9393
 TH1.cxx:9394
 TH1.cxx:9395
 TH1.cxx:9396
 TH1.cxx:9397
 TH1.cxx:9398
 TH1.cxx:9399
 TH1.cxx:9400
 TH1.cxx:9401
 TH1.cxx:9402
 TH1.cxx:9403
 TH1.cxx:9404
 TH1.cxx:9405
 TH1.cxx:9406
 TH1.cxx:9407
 TH1.cxx:9408
 TH1.cxx:9409
 TH1.cxx:9410
 TH1.cxx:9411
 TH1.cxx:9412
 TH1.cxx:9413
 TH1.cxx:9414
 TH1.cxx:9415
 TH1.cxx:9416
 TH1.cxx:9417
 TH1.cxx:9418
 TH1.cxx:9419
 TH1.cxx:9420
 TH1.cxx:9421
 TH1.cxx:9422
 TH1.cxx:9423
 TH1.cxx:9424
 TH1.cxx:9425
 TH1.cxx:9426
 TH1.cxx:9427
 TH1.cxx:9428
 TH1.cxx:9429
 TH1.cxx:9430
 TH1.cxx:9431
 TH1.cxx:9432
 TH1.cxx:9433
 TH1.cxx:9434
 TH1.cxx:9435
 TH1.cxx:9436
 TH1.cxx:9437
 TH1.cxx:9438
 TH1.cxx:9439
 TH1.cxx:9440
 TH1.cxx:9441
 TH1.cxx:9442
 TH1.cxx:9443
 TH1.cxx:9444
 TH1.cxx:9445
 TH1.cxx:9446
 TH1.cxx:9447
 TH1.cxx:9448
 TH1.cxx:9449
 TH1.cxx:9450
 TH1.cxx:9451
 TH1.cxx:9452
 TH1.cxx:9453
 TH1.cxx:9454
 TH1.cxx:9455
 TH1.cxx:9456
 TH1.cxx:9457
 TH1.cxx:9458
 TH1.cxx:9459
 TH1.cxx:9460
 TH1.cxx:9461
 TH1.cxx:9462
 TH1.cxx:9463
 TH1.cxx:9464
 TH1.cxx:9465
 TH1.cxx:9466
 TH1.cxx:9467
 TH1.cxx:9468
 TH1.cxx:9469
 TH1.cxx:9470
 TH1.cxx:9471
 TH1.cxx:9472
 TH1.cxx:9473
 TH1.cxx:9474
 TH1.cxx:9475
 TH1.cxx:9476
 TH1.cxx:9477
 TH1.cxx:9478
 TH1.cxx:9479
 TH1.cxx:9480
 TH1.cxx:9481
 TH1.cxx:9482
 TH1.cxx:9483
 TH1.cxx:9484
 TH1.cxx:9485
 TH1.cxx:9486
 TH1.cxx:9487
 TH1.cxx:9488
 TH1.cxx:9489
 TH1.cxx:9490
 TH1.cxx:9491
 TH1.cxx:9492
 TH1.cxx:9493
 TH1.cxx:9494
 TH1.cxx:9495
 TH1.cxx:9496
 TH1.cxx:9497
 TH1.cxx:9498
 TH1.cxx:9499
 TH1.cxx:9500
 TH1.cxx:9501
 TH1.cxx:9502
 TH1.cxx:9503
 TH1.cxx:9504
 TH1.cxx:9505
 TH1.cxx:9506
 TH1.cxx:9507
 TH1.cxx:9508
 TH1.cxx:9509
 TH1.cxx:9510
 TH1.cxx:9511
 TH1.cxx:9512
 TH1.cxx:9513
 TH1.cxx:9514
 TH1.cxx:9515
 TH1.cxx:9516
 TH1.cxx:9517
 TH1.cxx:9518
 TH1.cxx:9519
 TH1.cxx:9520
 TH1.cxx:9521
 TH1.cxx:9522
 TH1.cxx:9523
 TH1.cxx:9524
 TH1.cxx:9525
 TH1.cxx:9526
 TH1.cxx:9527
 TH1.cxx:9528
 TH1.cxx:9529
 TH1.cxx:9530
 TH1.cxx:9531
 TH1.cxx:9532
 TH1.cxx:9533
 TH1.cxx:9534
 TH1.cxx:9535
 TH1.cxx:9536
 TH1.cxx:9537
 TH1.cxx:9538
 TH1.cxx:9539
 TH1.cxx:9540
 TH1.cxx:9541
 TH1.cxx:9542
 TH1.cxx:9543
 TH1.cxx:9544
 TH1.cxx:9545
 TH1.cxx:9546
 TH1.cxx:9547
 TH1.cxx:9548
 TH1.cxx:9549
 TH1.cxx:9550
 TH1.cxx:9551
 TH1.cxx:9552
 TH1.cxx:9553
 TH1.cxx:9554
 TH1.cxx:9555
 TH1.cxx:9556
 TH1.cxx:9557
 TH1.cxx:9558
 TH1.cxx:9559
 TH1.cxx:9560
 TH1.cxx:9561
 TH1.cxx:9562
 TH1.cxx:9563
 TH1.cxx:9564
 TH1.cxx:9565
 TH1.cxx:9566
 TH1.cxx:9567
 TH1.cxx:9568
 TH1.cxx:9569
 TH1.cxx:9570
 TH1.cxx:9571
 TH1.cxx:9572
 TH1.cxx:9573
 TH1.cxx:9574
 TH1.cxx:9575
 TH1.cxx:9576
 TH1.cxx:9577
 TH1.cxx:9578
 TH1.cxx:9579
 TH1.cxx:9580
 TH1.cxx:9581
 TH1.cxx:9582
 TH1.cxx:9583
 TH1.cxx:9584
 TH1.cxx:9585
 TH1.cxx:9586
 TH1.cxx:9587
 TH1.cxx:9588
 TH1.cxx:9589
 TH1.cxx:9590
 TH1.cxx:9591
 TH1.cxx:9592
 TH1.cxx:9593
 TH1.cxx:9594
 TH1.cxx:9595
 TH1.cxx:9596
 TH1.cxx:9597
 TH1.cxx:9598
 TH1.cxx:9599
 TH1.cxx:9600
 TH1.cxx:9601
 TH1.cxx:9602
 TH1.cxx:9603
 TH1.cxx:9604
 TH1.cxx:9605
 TH1.cxx:9606
 TH1.cxx:9607
 TH1.cxx:9608
 TH1.cxx:9609
 TH1.cxx:9610
 TH1.cxx:9611
 TH1.cxx:9612
 TH1.cxx:9613
 TH1.cxx:9614
 TH1.cxx:9615
 TH1.cxx:9616
 TH1.cxx:9617
 TH1.cxx:9618
 TH1.cxx:9619
 TH1.cxx:9620
 TH1.cxx:9621
 TH1.cxx:9622
 TH1.cxx:9623
 TH1.cxx:9624
 TH1.cxx:9625
 TH1.cxx:9626
 TH1.cxx:9627
 TH1.cxx:9628
 TH1.cxx:9629
 TH1.cxx:9630
 TH1.cxx:9631
 TH1.cxx:9632
 TH1.cxx:9633
 TH1.cxx:9634
 TH1.cxx:9635
 TH1.cxx:9636
 TH1.cxx:9637
 TH1.cxx:9638
 TH1.cxx:9639
 TH1.cxx:9640
 TH1.cxx:9641
 TH1.cxx:9642
 TH1.cxx:9643
 TH1.cxx:9644
 TH1.cxx:9645
 TH1.cxx:9646
 TH1.cxx:9647
 TH1.cxx:9648
 TH1.cxx:9649
 TH1.cxx:9650
 TH1.cxx:9651
 TH1.cxx:9652
 TH1.cxx:9653
 TH1.cxx:9654
 TH1.cxx:9655
 TH1.cxx:9656
 TH1.cxx:9657
 TH1.cxx:9658
 TH1.cxx:9659
 TH1.cxx:9660
 TH1.cxx:9661
 TH1.cxx:9662
 TH1.cxx:9663
 TH1.cxx:9664
 TH1.cxx:9665
 TH1.cxx:9666
 TH1.cxx:9667
 TH1.cxx:9668
 TH1.cxx:9669
 TH1.cxx:9670
 TH1.cxx:9671
 TH1.cxx:9672
 TH1.cxx:9673
 TH1.cxx:9674
 TH1.cxx:9675
 TH1.cxx:9676
 TH1.cxx:9677
 TH1.cxx:9678
 TH1.cxx:9679
 TH1.cxx:9680
 TH1.cxx:9681
 TH1.cxx:9682
 TH1.cxx:9683
 TH1.cxx:9684
 TH1.cxx:9685
 TH1.cxx:9686
 TH1.cxx:9687
 TH1.cxx:9688
 TH1.cxx:9689
 TH1.cxx:9690
 TH1.cxx:9691
 TH1.cxx:9692
 TH1.cxx:9693
 TH1.cxx:9694
 TH1.cxx:9695
 TH1.cxx:9696
 TH1.cxx:9697
 TH1.cxx:9698
 TH1.cxx:9699
 TH1.cxx:9700
 TH1.cxx:9701
 TH1.cxx:9702
 TH1.cxx:9703
 TH1.cxx:9704
 TH1.cxx:9705
 TH1.cxx:9706
 TH1.cxx:9707
 TH1.cxx:9708
 TH1.cxx:9709
 TH1.cxx:9710
 TH1.cxx:9711
 TH1.cxx:9712
 TH1.cxx:9713
 TH1.cxx:9714
 TH1.cxx:9715
 TH1.cxx:9716
 TH1.cxx:9717
 TH1.cxx:9718
 TH1.cxx:9719
 TH1.cxx:9720
 TH1.cxx:9721
 TH1.cxx:9722
 TH1.cxx:9723
 TH1.cxx:9724
 TH1.cxx:9725
 TH1.cxx:9726
 TH1.cxx:9727
 TH1.cxx:9728
 TH1.cxx:9729
 TH1.cxx:9730
 TH1.cxx:9731
 TH1.cxx:9732
 TH1.cxx:9733
 TH1.cxx:9734
 TH1.cxx:9735
 TH1.cxx:9736
 TH1.cxx:9737
 TH1.cxx:9738
 TH1.cxx:9739
 TH1.cxx:9740
 TH1.cxx:9741
 TH1.cxx:9742
 TH1.cxx:9743
 TH1.cxx:9744
 TH1.cxx:9745
 TH1.cxx:9746
 TH1.cxx:9747
 TH1.cxx:9748
 TH1.cxx:9749
 TH1.cxx:9750
 TH1.cxx:9751
 TH1.cxx:9752
 TH1.cxx:9753
 TH1.cxx:9754
 TH1.cxx:9755
 TH1.cxx:9756
 TH1.cxx:9757
 TH1.cxx:9758
 TH1.cxx:9759
 TH1.cxx:9760
 TH1.cxx:9761
 TH1.cxx:9762
 TH1.cxx:9763
 TH1.cxx:9764
 TH1.cxx:9765
 TH1.cxx:9766
 TH1.cxx:9767
 TH1.cxx:9768
 TH1.cxx:9769
 TH1.cxx:9770
 TH1.cxx:9771
 TH1.cxx:9772
 TH1.cxx:9773
 TH1.cxx:9774