ROOT logo
// @(#)root/hist:$Id: TGraph.cxx 31801 2009-12-10 15:09:29Z moneta $
// Author: Rene Brun, Olivier Couet   12/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 <string.h>

#include "Riostream.h"
#include "TROOT.h"
#include "TEnv.h"
#include "TGraph.h"
#include "TGaxis.h"
#include "TH1.h"
#include "TF1.h"
#include "TStyle.h"
#include "TMath.h"
#include "TFrame.h"
#include "TVector.h"
#include "TVectorD.h"
#include "Foption.h"
#include "TRandom.h"
#include "TSpline.h"
#include "TPaveStats.h"
#include "TVirtualFitter.h"
#include "TVirtualPad.h"
#include "TVirtualGraphPainter.h"
#include "TBrowser.h"
#include "TClass.h"
#include "TSystem.h"
#include "TPluginManager.h"
#include <stdlib.h>
#include <string>
#include <cassert>

#include "HFitInterface.h"
#include "Fit/DataRange.h"
#include "Math/MinimizerOptions.h"

extern void H1LeastSquareSeqnd(Int_t n, Double_t *a, Int_t idim, Int_t &ifail, Int_t k, Double_t *b);

ClassImp(TGraph)


//______________________________________________________________________________
/* Begin_Html
<center><h2>Graph class</h2></center>
A Graph is a graphics object made of two arrays X and Y with npoints each.
<p>
The TGraph painting is permofed thanks to the
<a href="http://root.cern.ch/root/html/TGraphPainter.html">TGraphPainter</a>
class. All details about the various painting options are given in
<a href="http://root.cern.ch/root/html/TGraphPainter.html">this class</a>.
<p>
The picture below gives an example:
End_Html
Begin_Macro(source)
{
   TCanvas *c1 = new TCanvas("c1","A Simple Graph Example",200,10,700,500);
   Double_t x[100], y[100];
   Int_t n = 20;
   for (Int_t i=0;i<n;i++) {
     x[i] = i*0.1;
     y[i] = 10*sin(x[i]+0.2);
   }
   gr = new TGraph(n,x,y);
   gr->Draw("AC*");
   return c1;
}
End_Macro */


//______________________________________________________________________________
TGraph::TGraph(): TNamed(), TAttLine(), TAttFill(1,1001), TAttMarker()
{
   // Graph default constructor.

   fNpoints = -1;  //will be reset to 0 in CtorAllocate
   CtorAllocate();
}


//______________________________________________________________________________
TGraph::TGraph(Int_t n)
       : TNamed("Graph","Graph"), TAttLine(), TAttFill(1,1001), TAttMarker()
{
   // Constructor with only the number of points set
   // the arrsys x and y will be set later

   fNpoints = n;
   if (!CtorAllocate()) return;
   FillZero(0, fNpoints);
}


//______________________________________________________________________________
TGraph::TGraph(Int_t n, const Int_t *x, const Int_t *y)
       : TNamed("Graph","Graph"), TAttLine(), TAttFill(1,1001), TAttMarker()
{
   // Graph normal constructor with ints.

   if (!x || !y) {
      fNpoints = 0;
   } else {
      fNpoints = n;
   }
   if (!CtorAllocate()) return;
   for (Int_t i=0;i<n;i++) {
      fX[i] = (Double_t)x[i];
      fY[i] = (Double_t)y[i];
   }
}


//______________________________________________________________________________
TGraph::TGraph(Int_t n, const Float_t *x, const Float_t *y)
       : TNamed("Graph","Graph"), TAttLine(), TAttFill(1,1001), TAttMarker()
{
   // Graph normal constructor with floats.

   if (!x || !y) {
      fNpoints = 0;
   } else {
      fNpoints = n;
   }
   if (!CtorAllocate()) return;
   for (Int_t i=0;i<n;i++) {
      fX[i] = x[i];
      fY[i] = y[i];
   }
}


//______________________________________________________________________________
TGraph::TGraph(Int_t n, const Double_t *x, const Double_t *y)
       : TNamed("Graph","Graph"), TAttLine(), TAttFill(1,1001), TAttMarker()
{
   // Graph normal constructor with doubles.

   if (!x || !y) {
      fNpoints = 0;
   } else {
      fNpoints = n;
   }
   if (!CtorAllocate()) return;
   n = fNpoints*sizeof(Double_t);
   memcpy(fX, x, n);
   memcpy(fY, y, n);
}


//______________________________________________________________________________
TGraph::TGraph(const TGraph &gr)
       : TNamed(gr), TAttLine(gr), TAttFill(gr), TAttMarker(gr)
{
   // Copy constructor for this graph

   fNpoints = gr.fNpoints;
   fMaxSize = gr.fMaxSize;
   if (gr.fFunctions) fFunctions = (TList*)gr.fFunctions->Clone();
   else fFunctions = new TList;
   fHistogram = 0;
   fMinimum = gr.fMinimum;
   fMaximum = gr.fMaximum;
   if (!fMaxSize) {
      fX = fY = 0;
      return;
   } else {
      fX = new Double_t[fMaxSize];
      fY = new Double_t[fMaxSize];
   }

   Int_t n = gr.GetN()*sizeof(Double_t);
   memcpy(fX, gr.fX, n);
   memcpy(fY, gr.fY, n);
}


//______________________________________________________________________________
TGraph& TGraph::operator=(const TGraph &gr)
{
   // Equal operator for this graph

   if(this!=&gr) {
      TNamed::operator=(gr);
      TAttLine::operator=(gr);
      TAttFill::operator=(gr);
      TAttMarker::operator=(gr);

      fNpoints = gr.fNpoints;
      fMaxSize = gr.fMaxSize;
      if (gr.fFunctions) fFunctions = (TList*)gr.fFunctions->Clone();
      else fFunctions = new TList;
      if (gr.fHistogram) fHistogram = new TH1F(*(gr.fHistogram));
      else fHistogram = 0;
      fMinimum = gr.fMinimum;
      fMaximum = gr.fMaximum;
      if (!fMaxSize) {
         fX = fY = 0;
         return *this;
      } else {
         fX = new Double_t[fMaxSize];
         fY = new Double_t[fMaxSize];
      }

      Int_t n = gr.GetN()*sizeof(Double_t);
      if (n>0) {
         memcpy(fX, gr.fX, n);
         memcpy(fY, gr.fY, n);
      }
   }
   return *this;
}


//______________________________________________________________________________
TGraph::TGraph(const TVectorF &vx, const TVectorF &vy)
       : TNamed("Graph","Graph"), TAttLine(), TAttFill(1,1001), TAttMarker()
{
   // Graph constructor with two vectors of floats in input
   // A graph is build with the X coordinates taken from vx and Y coord from vy
   // The number of points in the graph is the minimum of number of points
   // in vx and vy.

   fNpoints = TMath::Min(vx.GetNrows(), vy.GetNrows());
   if (!CtorAllocate()) return;
   Int_t ivxlow  = vx.GetLwb();
   Int_t ivylow  = vy.GetLwb();
   for (Int_t i=0;i<fNpoints;i++) {
      fX[i]  = vx(i+ivxlow);
      fY[i]  = vy(i+ivylow);
   }
}


//______________________________________________________________________________
TGraph::TGraph(const TVectorD &vx, const TVectorD &vy)
       : TNamed("Graph","Graph"), TAttLine(), TAttFill(1,1001), TAttMarker()
{
   // Graph constructor with two vectors of doubles in input
   // A graph is build with the X coordinates taken from vx and Y coord from vy
   // The number of points in the graph is the minimum of number of points
   // in vx and vy.

   fNpoints = TMath::Min(vx.GetNrows(), vy.GetNrows());
   if (!CtorAllocate()) return;
   Int_t ivxlow  = vx.GetLwb();
   Int_t ivylow  = vy.GetLwb();
   for (Int_t i=0;i<fNpoints;i++) {
      fX[i]  = vx(i+ivxlow);
      fY[i]  = vy(i+ivylow);
   }
}


//______________________________________________________________________________
TGraph::TGraph(const TH1 *h)
       : TNamed("Graph","Graph"), TAttLine(), TAttFill(1,1001), TAttMarker()
{
   // Graph constructor importing its parameters from the TH1 object passed as argument

   if (!h) {
      Error("TGraph", "Pointer to histogram is null");
      fNpoints = 0;
   }
   if (h->GetDimension() != 1) {
      Error("TGraph", "Histogram must be 1-D; h %s is %d-D",h->GetName(),h->GetDimension());
      fNpoints = 0;
   } else {
      fNpoints = ((TH1*)h)->GetXaxis()->GetNbins();
   }

   if (!CtorAllocate()) return;

   TAxis *xaxis = ((TH1*)h)->GetXaxis();
   for (Int_t i=0;i<fNpoints;i++) {
      fX[i] = xaxis->GetBinCenter(i+1);
      fY[i] = h->GetBinContent(i+1);
   }
   h->TAttLine::Copy(*this);
   h->TAttFill::Copy(*this);
   h->TAttMarker::Copy(*this);

   std::string gname = "Graph_from_" + std::string(h->GetName() );
   SetName(gname.c_str());
   SetTitle(h->GetTitle());
}


//______________________________________________________________________________
TGraph::TGraph(const TF1 *f, Option_t *option)
       : TNamed("Graph","Graph"), TAttLine(), TAttFill(1,1001), TAttMarker()
{
   // Graph constructor importing its parameters from the TF1 object passed as argument
   // if option =="" (default), a TGraph is created with points computed
   //                at the fNpx points of f.
   // if option =="d", a TGraph is created with points computed with the derivatives
   //                at the fNpx points of f.
   // if option =="i", a TGraph is created with points computed with the integral
   //                at the fNpx points of f.
   // if option =="I", a TGraph is created with points computed with the integral
   //                at the fNpx+1 points of f and the integral is normalized to 1.

   char coption = ' ';
   if (!f) {
      Error("TGraph", "Pointer to function is null");
      fNpoints = 0;
   } else {
      fNpoints   = f->GetNpx();
      if (option) coption = *option;
      if (coption == 'i' || coption == 'I') fNpoints++;
   }
   if (!CtorAllocate()) return;

   Double_t xmin = f->GetXmin();
   Double_t xmax = f->GetXmax();
   Double_t dx   = (xmax-xmin)/fNpoints;
   Double_t integ = 0;
   Int_t i;
   for (i=0;i<fNpoints;i++) {
      if (coption == 'i' || coption == 'I') {
         fX[i] = xmin +i*dx;
         if (i == 0) fY[i] = 0;
         else        fY[i] = integ + ((TF1*)f)->Integral(fX[i]-dx,fX[i]);
         integ = fY[i];
      } else if (coption == 'd' || coption == 'D') {
         fX[i] = xmin + (i+0.5)*dx;
         fY[i] = ((TF1*)f)->Derivative(fX[i]);
      } else {
         fX[i] = xmin + (i+0.5)*dx;
         fY[i] = ((TF1*)f)->Eval(fX[i]);
      }
   }
   if (integ != 0 && coption == 'I') {
      for (i=1;i<fNpoints;i++) fY[i] /= integ;
   }

   f->TAttLine::Copy(*this);
   f->TAttFill::Copy(*this);
   f->TAttMarker::Copy(*this);

   SetName(f->GetName());
   SetTitle(f->GetTitle());
}


//______________________________________________________________________________
TGraph::TGraph(const char *filename, const char *format, Option_t *)
       : TNamed("Graph",filename), TAttLine(), TAttFill(1,1001), TAttMarker()
{
   // Graph constructor reading input from filename
   // filename is assumed to contain at least two columns of numbers
   // the string format is by default "%lg %lg"

   Double_t x,y;
   ifstream infile(filename);
   if(!infile.good()){
      MakeZombie();
      Error("TGraph", "Cannot open file: %s, TGraph is Zombie",filename);
      fNpoints = 0;
   } else {
      fNpoints = 100;  //initial number of points
   }
   if (!CtorAllocate()) return;
   std::string line;
   Int_t np=0;
   while(std::getline(infile,line,'\n')){
      if(2 != sscanf(line.c_str(),format,&x,&y) ) {
         continue; // skip empty and ill-formed lines
      }
      SetPoint(np,x,y);
      np++;
   }
   Set(np);
}


//______________________________________________________________________________
TGraph::~TGraph()
{
   // Graph default destructor.

   delete [] fX;
   delete [] fY;
   if (fFunctions) {
      fFunctions->SetBit(kInvalidObject);
      //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;
      }
      delete fFunctions;
      fFunctions = 0; //to avoid accessing a deleted object in RecursiveRemove
   }
   delete fHistogram;
}


//______________________________________________________________________________
Double_t** TGraph::AllocateArrays(Int_t Narrays, Int_t arraySize)
{
   // Allocate arrays.

   if (arraySize < 0) { arraySize = 0; }
   Double_t **newarrays = new Double_t*[Narrays];
   if (!arraySize) {
      for (Int_t i = 0; i < Narrays; ++i)
         newarrays[i] = 0;
   } else {
      for (Int_t i = 0; i < Narrays; ++i)
         newarrays[i] = new Double_t[arraySize];
   }
   fMaxSize = arraySize;
   return newarrays;
}


//______________________________________________________________________________
void TGraph::Apply(TF1 *f)
{
   // Apply function f to all the data points
   // f may be a 1-D function TF1 or 2-d function TF2
   // The Y values of the graph are replaced by the new values computed
   // using the function

   for (Int_t i=0;i<fNpoints;i++) {
      fY[i] = f->Eval(fX[i],fY[i]);
   }
}


//______________________________________________________________________________
void TGraph::Browse(TBrowser *b)
{
   // Browse

   TString opt = gEnv->GetValue("TGraph.BrowseOption","");
   if (opt.IsNull()) {
      opt = b ? b->GetDrawOption() : "alp";
   }
   Draw(opt.Data());
   gPad->Update();
}


//______________________________________________________________________________
Double_t TGraph::Chisquare(const TF1 *f1) const
{
   // Return the chisquare of this graph with respect to f1.
   // The chisquare is computed as the sum of the quantity below at each point:
   // Begin_Latex
   // #frac{(y-f1(x))^{2}}{ey^{2}+(#frac{1}{2}(exl+exh)f1'(x))^{2}}
   // End_latex
   // where x and y are the graph point coordinates and f1'(x) is the derivative of function f1(x).
   // This method to approximate the uncertainty in y because of the errors in x, is called
   // "effective variance" method.
   // In case of a pure TGraph, the denominator is 1.
   // In case of a TGraphErrors or TGraphAsymmErrors the errors are taken
   // into account.

   if (!f1) return 0;
   Double_t cu,eu,exh,exl,ey,eux,fu,fsum;
   Double_t x[1];
   Double_t chi2 = 0;
   TF1 *func = (TF1*)f1; //EvalPar is not const !
   for (Int_t i=0;i<fNpoints;i++) {
      func->InitArgs(x,0); //must be inside the loop because of TF1::Derivative calling InitArgs
      x[0] = fX[i];
      if (!func->IsInside(x)) continue;
      cu   = fY[i];
      TF1::RejectPoint(kFALSE);
      fu   = func->EvalPar(x);
      if (TF1::RejectedPoint()) continue;
      fsum = (cu-fu);
      //npfits++;
      exh = GetErrorXhigh(i);
      exl = GetErrorXlow(i);
      if (fsum < 0)
         ey = GetErrorYhigh(i);
      else
         ey = GetErrorYlow(i);
      if (exl < 0) exl = 0;
      if (exh < 0) exh = 0;
      if (ey < 0)  ey  = 0;
      if (exh > 0 || exl > 0) {
         //"Effective Variance" method introduced by Anna Kreshuk
         //a copy of the algorithm in GraphFitChisquare from TFitter
         eux = 0.5*(exl + exh)*func->Derivative(x[0]);
      } else
         eux = 0.;
      eu = ey*ey+eux*eux;
      if (eu <= 0) eu = 1;
      chi2 += fsum*fsum/eu;
   }
   return chi2;
}


//______________________________________________________________________________
Bool_t TGraph::CompareArg(const TGraph* gr, Int_t left, Int_t right)
{
   // Return kTRUE if point number "left"'s argument (angle with respect to positive
   // x-axis) is bigger than that of point number "right". Can be used by Sort.

   Double_t xl,yl,xr,yr;
   gr->GetPoint(left,xl,yl);
   gr->GetPoint(right,xr,yr);
   return (TMath::ATan2(yl, xl) > TMath::ATan2(yr, xr));
}


//______________________________________________________________________________
Bool_t TGraph::CompareX(const TGraph* gr, Int_t left, Int_t right)
{
   // Return kTRUE if fX[left] > fX[right]. Can be used by Sort.

   return gr->fX[left]>gr->fX[right];
}


//______________________________________________________________________________
Bool_t TGraph::CompareY(const TGraph* gr, Int_t left, Int_t right)
{
   // Return kTRUE if fY[left] > fY[right]. Can be used by Sort.

   return gr->fY[left]>gr->fY[right];
}


//______________________________________________________________________________
Bool_t TGraph::CompareRadius(const TGraph* gr, Int_t left, Int_t right)
{
   // Return kTRUE if point number "left"'s distance to origin is bigger than
   // that of point number "right". Can be used by Sort.

   return gr->fX[left]*gr->fX[left]+gr->fY[left]*gr->fY[left]
      >gr->fX[right]*gr->fX[right]+gr->fY[right]*gr->fY[right];
}


//______________________________________________________________________________
void TGraph::ComputeRange(Double_t &xmin, Double_t &ymin, Double_t &xmax, Double_t &ymax) const
{
   // Compute the x/y range of the points in this graph
   if (fNpoints <= 0) {
      xmin=xmax=ymin=ymax = 0;
      return;
   }
   xmin = xmax = fX[0];
   ymin = ymax = fY[0];
   for (Int_t i=1;i<fNpoints;i++) {
      if (fX[i] < xmin) xmin = fX[i];
      if (fX[i] > xmax) xmax = fX[i];
      if (fY[i] < ymin) ymin = fY[i];
      if (fY[i] > ymax) ymax = fY[i];
   }
}


//______________________________________________________________________________
void TGraph::CopyAndRelease(Double_t **newarrays, Int_t ibegin, Int_t iend,
                           Int_t obegin)
{
   // Copy points from fX and fY to arrays[0] and arrays[1]
   // or to fX and fY if arrays == 0 and ibegin != iend.
   // If newarrays is non null, replace fX, fY with pointers from newarrays[0,1].
   // Delete newarrays, old fX and fY

   CopyPoints(newarrays, ibegin, iend, obegin);
   if (newarrays) {
      delete[] fX;
      fX = newarrays[0];
      delete[] fY;
      fY = newarrays[1];
      delete[] newarrays;
   }
}


//______________________________________________________________________________
Bool_t TGraph::CopyPoints(Double_t **arrays, Int_t ibegin, Int_t iend,
                        Int_t obegin)
{
   // Copy points from fX and fY to arrays[0] and arrays[1]
   // or to fX and fY if arrays == 0 and ibegin != iend.

   if (ibegin < 0 || iend <= ibegin || obegin < 0) { // Error;
      return kFALSE;
   }
   if (!arrays && ibegin == obegin) { // No copying is needed
      return kFALSE;
   }
   Int_t n = (iend - ibegin)*sizeof(Double_t);
   if (arrays) {
      memmove(&arrays[0][obegin], &fX[ibegin], n);
      memmove(&arrays[1][obegin], &fY[ibegin], n);
   } else {
      memmove(&fX[obegin], &fX[ibegin], n);
      memmove(&fY[obegin], &fY[ibegin], n);
   }
   return kTRUE;
}


//______________________________________________________________________________
Bool_t TGraph::CtorAllocate()
{
   // In constructors set fNpoints than call this method.
   // Return kFALSE if the graph will contain no points.

   fHistogram = 0;
   fMaximum = -1111;
   fMinimum = -1111;
   SetBit(kClipFrame);
   fFunctions = new TList;
   if (fNpoints <= 0) {
      fNpoints = 0;
      fMaxSize   = 0;
      fX         = 0;
      fY         = 0;
      return kFALSE;
   } else {
      fMaxSize   = fNpoints;
      fX = new Double_t[fMaxSize];
      fY = new Double_t[fMaxSize];
   }
   return kTRUE;
}


//______________________________________________________________________________
void TGraph::Draw(Option_t *option)
{
   /* Begin_Html
   Draw this graph with its current attributes.
   <p>
   The ptions to draw a graph are described in
   <a href="http://root.cern.ch/root/html/TGraphPainter.html">TGraphPainter</a>
   class.
   End_Html */

   TString opt = option;
   opt.ToLower();

   if (opt.Contains("same")) {
      opt.ReplaceAll("same","");
   }

   // in case of option *, set marker style to 3 (star) and replace
   // * option by option P.
   Ssiz_t pos;
   if ((pos = opt.Index("*")) != kNPOS) {
      SetMarkerStyle(3);
      opt.Replace(pos, 1, "p");
   }
   if (gPad) {
      if (!gPad->IsEditable()) gROOT->MakeDefCanvas();
      if (opt.Contains("a")) gPad->Clear();
   }
   AppendPad(opt);
}


//______________________________________________________________________________
Int_t TGraph::DistancetoPrimitive(Int_t px, Int_t py)
{
   // Compute distance from point px,py to a graph.
   //
   //  Compute the closest distance of approach from point px,py to this line.
   //  The distance is computed in pixels units.

   return TVirtualGraphPainter::GetPainter()->DistancetoPrimitiveHelper(this, px,py);
}


//______________________________________________________________________________
void TGraph::DrawGraph(Int_t n, const Int_t *x, const Int_t *y, Option_t *option)
{
   // Draw this graph with new attributes.

   TGraph *newgraph = new TGraph(n, x, y);
   TAttLine::Copy(*newgraph);
   TAttFill::Copy(*newgraph);
   TAttMarker::Copy(*newgraph);
   newgraph->SetBit(kCanDelete);
   newgraph->AppendPad(option);
}


//______________________________________________________________________________
void TGraph::DrawGraph(Int_t n, const Float_t *x, const Float_t *y, Option_t *option)
{
   // Draw this graph with new attributes.

   TGraph *newgraph = new TGraph(n, x, y);
   TAttLine::Copy(*newgraph);
   TAttFill::Copy(*newgraph);
   TAttMarker::Copy(*newgraph);
   newgraph->SetBit(kCanDelete);
   newgraph->AppendPad(option);
}


//______________________________________________________________________________
void TGraph::DrawGraph(Int_t n, const Double_t *x, const Double_t *y, Option_t *option)
{
   // Draw this graph with new attributes.

   const Double_t *xx = x;
   const Double_t *yy = y;
   if (!xx) xx = fX;
   if (!yy) yy = fY;
   TGraph *newgraph = new TGraph(n, xx, yy);
   TAttLine::Copy(*newgraph);
   TAttFill::Copy(*newgraph);
   TAttMarker::Copy(*newgraph);
   newgraph->SetBit(kCanDelete);
   newgraph->AppendPad(option);
}


//______________________________________________________________________________
void TGraph::DrawPanel()
{
   // Display a panel with all graph drawing options.

   TVirtualGraphPainter::GetPainter()->DrawPanelHelper(this);
}


//______________________________________________________________________________
Double_t TGraph::Eval(Double_t x, TSpline *spline, Option_t *option) const
{
   // Interpolate points in this graph at x using a TSpline
   //  -if spline==0 and option="" a linear interpolation between the two points
   //   close to x is computed. If x is outside the graph range, a linear
   //   extrapolation is computed.
   //  -if spline==0 and option="S" a TSpline3 object is created using this graph
   //   and the interpolated value from the spline is returned.
   //   the internally created spline is deleted on return.
   //  -if spline is specified, it is used to return the interpolated value.


   if (!spline) {

      if (fNpoints == 0) return 0;
      if (fNpoints == 1) return fY[0];


      TString opt = option;
      opt.ToLower();
      if (opt.Contains("s")) {

         // points must be sorted before using a TSpline
         std::vector<Double_t> xsort(fNpoints);
         std::vector<Double_t> ysort(fNpoints);
         std::vector<Int_t> indxsort(fNpoints);
         TMath::Sort(fNpoints, fX, &indxsort[0], false );
         for (Int_t i = 0; i < fNpoints; ++i) {
            xsort[i] = fX[ indxsort[i] ];
            ysort[i] = fY[ indxsort[i] ];
         }

         // spline interpolation creating a new spline
         TSpline3 *s = new TSpline3("",&xsort[0], &ysort[0], fNpoints);
         Double_t result = s->Eval(x);
         delete s;
         return result;
      }
      //linear interpolation
      //In case x is < fX[0] or > fX[fNpoints-1] return the extrapolated point

      //find points in graph around x assuming points are not sorted
      // (if point are sorted could use binary search)

      // find neighbours simply looping  all points
      // and find also the 2 adjacent points: (low2 < low < x < up < up2 )
      // needed in case x is outside the graph ascissa interval
      Int_t low  = -1;  Int_t up  = -1;
      Int_t low2 = -1;  Int_t up2 = -1;

      for (Int_t i = 0; i < fNpoints; ++i) {
         if ( fX[i] < x ) {
            if  (low == -1 || fX[i] > fX[low] )  {  low2 = low;   low = i; }
            else if ( low2 == -1  ) low2 = i;
         }
         if ( fX[i] > x) {
            if (up  == -1 || fX[i] < fX[up]  )  {  up2 = up;     up = i;  }
            else if (up2 == -1) up2 = i;
         }
      }

      // treat cases when x is outside graph min max abscissa
      if (up == -1)  {up  = low; low = low2;}
      if (low == -1) {low = up;  up  = up2;  }

      assert( low != -1 && up != -1);

      if (fX[low] == fX[up]) return fY[low];
      Double_t yn = fY[up] + (x - fX[up] ) * (fY[low]-fY[up] ) / ( fX[low] - fX[up] );
      return yn;
   } else {
      //spline interpolation using the input spline
      return spline->Eval(x);
   }
}


//______________________________________________________________________________
void TGraph::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
   // Execute action corresponding to one event.
   //
   //  This member function is called when a graph is clicked with the locator
   //
   //  If Left button clicked on one of the line end points, this point
   //     follows the cursor until button is released.
   //
   //  if Middle button clicked, the line is moved parallel to itself
   //     until the button is released.

   TVirtualGraphPainter::GetPainter()->ExecuteEventHelper(this, event, px, py);
}


//______________________________________________________________________________
void TGraph::Expand(Int_t newsize)
{
   // If array sizes <= newsize, expand storage to 2*newsize.

   Double_t **ps = ExpandAndCopy(newsize, fNpoints);
   CopyAndRelease(ps, 0, 0, 0);
}


//______________________________________________________________________________
void TGraph::Expand(Int_t newsize, Int_t step)
{
   // If graph capacity is less than newsize points then make array sizes
   // equal to least multiple of step to contain newsize points.
   // Returns kTRUE if size was altered

   if (newsize <= fMaxSize) {
      return;
   }
   Double_t **ps = Allocate(step*(newsize/step + (newsize%step?1:0)));
   CopyAndRelease(ps, 0, fNpoints, 0);
}


//______________________________________________________________________________
Double_t **TGraph::ExpandAndCopy(Int_t size, Int_t iend)
{
   // if size > fMaxSize allocate new arrays of 2*size points
   //  and copy oend first points.
   // Return pointer to new arrays.

   if (size <= fMaxSize) { return 0; }
   Double_t **newarrays = Allocate(2*size);
   CopyPoints(newarrays, 0, iend, 0);
   return newarrays;
}


//______________________________________________________________________________
void TGraph::FillZero(Int_t begin, Int_t end, Bool_t)
{
   // Set zero values for point arrays in the range [begin, end)
   // Should be redefined in descendant classes

   memset(fX + begin, 0, (end - begin)*sizeof(Double_t));
   memset(fY + begin, 0, (end - begin)*sizeof(Double_t));
}


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

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


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

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


//______________________________________________________________________________
TFitResultPtr TGraph::Fit(const char *fname, Option_t *option, Option_t *, Axis_t xmin, Axis_t xmax)
{
   // Fit this graph with function with name fname.
   //
   //  interface to TGraph::Fit(TF1 *f1...
   //
   //      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)"

   char *linear;
   linear= (char*) strstr(fname, "++");
   TF1 *f1=0;
   if (linear)
      f1=new TF1(fname, fname, xmin, xmax);
   else {
      f1 = (TF1*)gROOT->GetFunction(fname);
      if (!f1) { Printf("Unknown function: %s",fname); return -1; }
   }
   return Fit(f1,option,"",xmin,xmax);
}


//______________________________________________________________________________
TFitResultPtr TGraph::Fit(TF1 *f1, Option_t *option, Option_t *goption, Axis_t rxmin, Axis_t rxmax)
{
   // Fit this graph with function f1.
   //
   //   f1 is an already predefined function created by TF1.
   //   Predefined functions such as gaus, expo and poln are automatically
   //   created by ROOT.
   //
   //   The list of fit options is given in parameter option.
   //      option = "W" Set all weights to 1; ignore error bars
   //             = "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, do not calculate the chisquare
   //                    (saves time)
   //             = "F" If fitting a polN, use the minuit fitter
   //             = "EX0" When fitting a TGraphErrors do not consider errors in the coordinate
   //             = "ROB" In case of linear fitting, compute the LTS regression
   //                     coefficients (robust (resistant) regression), using
   //                     the default fraction of good points
   //               "ROB=0.x" - compute the LTS regression coefficients, using
   //                           0.x as a fraction of good points
   //             = "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 TGraphPainter 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 graph
   //   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);
   //        graph->Fit("f1","R");
   //
   //
   // Who is calling this function:
   //
   //   Note that this function is called when calling TGraphErrors::Fit
   //   or TGraphAsymmErrors::Fit ot TGraphBentErrors::Fit
   //   See the discussion below on error calulation.
   //
   // Linear fitting:
   //
   //   When the fitting function is linear (contains the "++" sign) or the fitting
   //   function is a polynomial, a linear fitter is initialised.
   //   To create a linear function, use the following syntax: linear parts
   //   separated by "++" sign.
   //   Example: to fit the parameters of "[0]*x + [1]*sin(x)", create a
   //    TF1 *f1=new TF1("f1", "x++sin(x)", xmin, xmax);
   //   For such a TF1 you don't have to set the initial conditions.
   //   Going via the linear fitter for functions, linear in parameters, gives a 
   //   considerable advantage in speed.
   //
   // 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".
   //   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,0.1,-8,100);
   //     func->SetParLimits(4,-10,-4);
   //     func->SetParLimits(5, 1,1);
   //   With this setup, parameters 0->3 can vary freely.
   //   Parameter 4 has boundaries [-10,-4] with initial value -8.
   //   Parameter 5 is fixed to 100.
   //
   // Fit range:
   //
   //   The fit range can be specified in two ways:
   //     - specify rxmax > rxmin (default is rxmin=rxmax=0)
   //     - specify the option "R". In this case, the function will be taken
   //       instead of the full graph range.
   //
   // Changing the fitting function:
   //
   //   By default a chi2 fitting function is used for fitting a TGraph.
   //   The function is implemented in FitUtil::EvaluateChi2. 
   //   In case of TGraphErrors an effective chi2 is used (see below)
   //   To specify a User defined fitting function, specify option "U" and
   //   call the following functions:
   //     TVirtualFitter::Fitter(mygraph)->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);
   //
   // How errors are used in the chisquare function (see TFitter GraphFitChisquare)
   // 
   //      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 and it converts
   //  automatically to an integer. If the option "S" is instead used, TFitResultPtr contains
   //  the TFitResult and behaves as a smart pointer to it. For example one can do: 
   //     TFitResult r    = graph->Fit("myFunc","S");
   //     TMatrixDSym cov = r->GetCovarianceMatrix();  //  to access the covariance matrix
   //     Double_t par0   = r->Value(0); // retrieve the value for the parameter 0 
   //     Double_t err0   = r->Error(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. 
   //
   //   In case of a TGraphErrors object, ex, the error along x, is projected
   //   along the y-direction by calculating the function at the points x-exlow and
   //   x+exhigh.
   //
   //   The chisquare is computed as the sum of the quantity below at each point:
   //
   // Begin_Latex
   // #frac{(y-f(x))^{2}}{ey^{2}+(#frac{1}{2}(exl+exh)f'(x))^{2}}
   // End_Latex
   //
   //   where x and y are the point coordinates, and f'(x) is the derivative of the
   //   function f(x).
   //
   //   In case the function lies below (above) the data point, ey is ey_low (ey_high).
   //
   //   thanks to Andy Haas (haas@yahoo.com) for adding the case with TGraphAsymmErrors
   //             University of Washington
   //
   //   The approach used to approximate the uncertainty in y because of the
   //   errors in x is to make it equal the error in x times the slope of the line.
   //   The improvement, compared to the first method (f(x+ exhigh) - f(x-exlow))/2
   //   is of (error of x)**2 order. This approach is called "effective variance method".
   //   This improvement has been made in version 4.00/08 by Anna Kreshuk.
   //   The implementation is provided in the function FitUtil::EvaluateChi2Effective
   //
   // NOTE:
   //   1) By using the "effective variance" method a simple linear regression
   //      becomes a non-linear case, which takes several iterations
   //      instead of 0 as in the linear case.
   //
   //   2) The effective variance technique assumes that there is no correlation
   //      between the x and y coordinate.
   //
   //   3) The standard chi2 (least square) method without error in the coordinates (x) can 
   //       be forced by using option "EX0"
   //
   //   4)  The linear fitter doesn't take into account the errors in x. When fitting a 
   //       TGraphErrors with a linear functions the errors in x willnot be considere.
   //        If errors in x are important, go through minuit (use option "F" for polynomial fitting).
   //
   //   5) When fitting a TGraph (i.e. no errors associated with each point),
   //   a correction is applied to the errors on the parameters with the following
   //   formula:
   //      errorp *= sqrt(chisquare/(ndf-1))
   //
   // Associated functions:
   //
   //   One or more object (typically a TF1*) can be added to the list
   //   of functions (fFunctions) associated with each graph.
   //   When TGraph::Fit is invoked, the fitted function is added to this list.
   //   Given a graph gr, one can retrieve an associated function
   //   with:  TF1 *myfunc = gr->GetFunction("myfunc");
   //
   //   If the graph 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
   //
   // Fit Statistics
   //
   //   You can change the statistics box to display the fit parameters with
   //   the TStyle::SetOptFit(mode) method. This mode has four digits.
   //   mode = pcev  (default = 0111)
   //     v = 1;  print name/values of parameters
   //     e = 1;  print errors (if e=1, v must be 1)
   //     c = 1;  print Chisquare/Number of degress of freedom
   //     p = 1;  print Probability
   //
   //   For example: gStyle->SetOptFit(1011);
   //   prints the fit probability, parameter names/values, and errors.
   //   You can change the position of the statistics box with these lines
   //   (where g is a pointer to the TGraph):
   //
   //   Root > TPaveStats *st = (TPaveStats*)g->GetListOfFunctions()->FindObject("stats")
   //   Root > st->SetX1NDC(newx1); //new x start position
   //   Root > st->SetX2NDC(newx2); //new x end position
   //
   //      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->Value(0); // retrieve the value for the parameter 0 
   //  Double_t err0   = r->Error(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 
   //  indipendently 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.
   //

   Foption_t fitOption;
   ROOT::Fit::FitOptionsMake(option,fitOption);
   // create range and minimizer options with default values 
   ROOT::Fit::DataRange range(rxmin,rxmax); 
   ROOT::Math::MinimizerOptions minOption; 
   return ROOT::Fit::FitObject(this, f1 , fitOption , minOption, goption, range);
}


//______________________________________________________________________________
void TGraph::FitPanel()
{
   // Display a GUI panel with all graph fit options.
   //
   //   See class TFitEditor 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 crate the FitPanel");
   }
   else
         Error("FitPanel", "Unable to find the FitPanel plug-in");
}


//______________________________________________________________________________
Double_t TGraph::GetCorrelationFactor() const
{
   // Return graph correlation factor

   Double_t rms1 = GetRMS(1);
   if (rms1 == 0) return 0;
   Double_t rms2 = GetRMS(2);
   if (rms2 == 0) return 0;
   return GetCovariance()/rms1/rms2;
}


//______________________________________________________________________________
Double_t TGraph::GetCovariance() const
{
   // Return covariance of vectors x,y

   if (fNpoints <= 0) return 0;
   Double_t sum = fNpoints, sumx = 0, sumy = 0, sumxy = 0;

   for (Int_t i=0;i<fNpoints;i++) {
      sumx  += fX[i];
      sumy  += fY[i];
      sumxy += fX[i]*fY[i];
   }
   return sumxy/sum - sumx/sum*sumy/sum;
}


//______________________________________________________________________________
Double_t TGraph::GetMean(Int_t axis) const
{
   // Return mean value of X (axis=1)  or Y (axis=2)

   if (axis < 1 || axis > 2) return 0;
   if (fNpoints <= 0) return 0;
   Double_t sumx = 0;
   for (Int_t i=0;i<fNpoints;i++) {
      if (axis == 1) sumx += fX[i];
      else           sumx += fY[i];
   }
   return sumx/fNpoints;
}


//______________________________________________________________________________
Double_t TGraph::GetRMS(Int_t axis) const
{
   // Return RMS of X (axis=1)  or Y (axis=2)

   if (axis < 1 || axis > 2) return 0;
   if (fNpoints <= 0) return 0;
   Double_t sumx = 0, sumx2 = 0;
   for (Int_t i=0;i<fNpoints;i++) {
      if (axis == 1) {sumx += fX[i]; sumx2 += fX[i]*fX[i];}
      else           {sumx += fY[i]; sumx2 += fY[i]*fY[i];}
   }
   Double_t x = sumx/fNpoints;
   Double_t rms2 = TMath::Abs(sumx2/fNpoints -x*x);
   return TMath::Sqrt(rms2);
}


//______________________________________________________________________________
Double_t TGraph::GetErrorX(Int_t) const
{
   // This function is called by GraphFitChisquare.
   // It always returns a negative value. Real implementation in TGraphErrors

   return -1;
}


//______________________________________________________________________________
Double_t TGraph::GetErrorY(Int_t) const
{
   // This function is called by GraphFitChisquare.
   // It always returns a negative value. Real implementation in TGraphErrors

   return -1;
}


//______________________________________________________________________________
Double_t TGraph::GetErrorXhigh(Int_t) const
{
   // This function is called by GraphFitChisquare.
   // It always returns a negative value. Real implementation in TGraphErrors
   // and TGraphAsymmErrors

   return -1;
}


//______________________________________________________________________________
Double_t TGraph::GetErrorXlow(Int_t) const
{
   // This function is called by GraphFitChisquare.
   // It always returns a negative value. Real implementation in TGraphErrors
   // and TGraphAsymmErrors

   return -1;
}


//______________________________________________________________________________
Double_t TGraph::GetErrorYhigh(Int_t) const
{
   // This function is called by GraphFitChisquare.
   // It always returns a negative value. Real implementation in TGraphErrors
   // and TGraphAsymmErrors

   return -1;
}


//______________________________________________________________________________
Double_t TGraph::GetErrorYlow(Int_t) const
{
   // This function is called by GraphFitChisquare.
   // It always returns a negative value. Real implementation in TGraphErrors
   // and TGraphAsymmErrors

   return -1;
}


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

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


//______________________________________________________________________________
TH1F *TGraph::GetHistogram() const
{
   // Returns a pointer to the histogram used to draw the axis
   // Takes into account the two following cases.
   //    1- option 'A' was specified in TGraph::Draw. Return fHistogram
   //    2- user had called TPad::DrawFrame. return pointer to hframe histogram

   Double_t rwxmin,rwxmax, rwymin, rwymax, maximum, minimum, dx, dy;
   Double_t uxmin, uxmax;

   ComputeRange(rwxmin, rwymin, rwxmax, rwymax);  //this is redefined in TGraphErrors

   // (if fHistogram exist) && (if the log scale is on) &&
   // (if the computed range minimum is > 0) && (if the fHistogram minimum is zero)
   // then it means fHistogram limits have been computed in linear scale
   // therefore they might be too strict and cut some points. In that case the
   // fHistogram limits should be recomputed ie: the existing fHistogram
   // should not be returned.
   if (fHistogram) {
      if (gPad && gPad->GetLogx()) {
         if (rwxmin <= 0 || fHistogram->GetXaxis()->GetXmin() != 0) return fHistogram;
      } else if (gPad && gPad->GetLogy()) {
         if (rwymin <= 0 || fHistogram->GetMinimum() != 0) return fHistogram;
      } else {
         return fHistogram;
      }
   }

   if (rwxmin == rwxmax) rwxmax += 1.;
   if (rwymin == rwymax) rwymax += 1.;
   dx = 0.1*(rwxmax-rwxmin);
   dy = 0.1*(rwymax-rwymin);
   uxmin    = rwxmin - dx;
   uxmax    = rwxmax + dx;
   minimum  = rwymin - dy;
   maximum  = rwymax + dy;
   if (fMinimum != -1111) minimum = fMinimum;
   if (fMaximum != -1111) maximum = fMaximum;

   // the graph is created with at least as many channels as there are points
   // to permit zooming on the full range
   if (uxmin < 0 && rwxmin >= 0) {
      if (gPad && gPad->GetLogx()) uxmin = 0.9*rwxmin;
      else                 uxmin = 0;
   }
   if (uxmax > 0 && rwxmax <= 0) {
      if (gPad && gPad->GetLogx()) uxmax = 1.1*rwxmax;
      else                 uxmax = 0;
   }
   if (minimum < 0 && rwymin >= 0) {
      if(gPad && gPad->GetLogy()) minimum = 0.9*rwymin;
      else                minimum = 0;
   }
   if (minimum <= 0 && gPad && gPad->GetLogy()) minimum = 0.001*maximum;
   if (uxmin <= 0 && gPad && gPad->GetLogx()) {
      if (uxmax > 1000) uxmin = 1;
      else              uxmin = 0.001*uxmax;
   }

   rwxmin = uxmin;
   rwxmax = uxmax;
   Int_t npt = 100;
   if (fNpoints > npt) npt = fNpoints;
   const char *gname = GetName();
   if (strlen(gname) == 0) gname = "Graph";
   ((TGraph*)this)->fHistogram = new TH1F(gname,GetTitle(),npt,rwxmin,rwxmax);
   if (!fHistogram) return 0;
   fHistogram->SetMinimum(minimum);
   fHistogram->SetBit(TH1::kNoStats);
   fHistogram->SetMaximum(maximum);
   fHistogram->GetYaxis()->SetLimits(minimum,maximum);
   fHistogram->SetDirectory(0);
   return fHistogram;
}


//______________________________________________________________________________
Int_t TGraph::GetPoint(Int_t i, Double_t &x, Double_t &y) const
{
   // Get x and y values for point number i.
   // The function returns -1 in case of an invalid request or the point number otherwise

   if (i < 0 || i >= fNpoints) return -1;
   if (!fX || !fY) return -1;
   x = fX[i];
   y = fY[i];
   return i;
}


//______________________________________________________________________________
TAxis *TGraph::GetXaxis() const
{
   // Get x axis of the graph.

   TH1 *h = GetHistogram();
   if (!h) return 0;
   return h->GetXaxis();
}


//______________________________________________________________________________
TAxis *TGraph::GetYaxis() const
{
   // Get y axis of the graph.

   TH1 *h = GetHistogram();
   if (!h) return 0;
   return h->GetYaxis();
}


//______________________________________________________________________________
void TGraph::InitGaus(Double_t xmin, Double_t xmax)
{
   // 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 graph in the given range
   if (xmax <= xmin) {xmin = fX[0]; xmax = fX[fNpoints-1];}
   Int_t np = 0;
   allcha = sumx = sumx2 = 0;
   for (bin=0;bin<fNpoints;bin++) {
      x       = fX[bin];
      if (x < xmin || x > xmax) continue;
      np++;
      val     = fY[bin];
      sumx   += val*x;
      sumx2  += val*x*x;
      allcha += val;
   }
   if (np == 0 || allcha == 0) return;
   mean = sumx/allcha;
   rms  = TMath::Sqrt(sumx2/allcha - mean*mean);
   Double_t binwidx = TMath::Abs((xmax-xmin)/np);
   if (rms == 0) rms = 1;
   TVirtualFitter *grFitter = TVirtualFitter::GetFitter();
   TF1 *f1 = (TF1*)grFitter->GetUserFunc();
   f1->SetParameter(0,binwidx*allcha/(sqrtpi*rms));
   f1->SetParameter(1,mean);
   f1->SetParameter(2,rms);
   f1->SetParLimits(2,0,10*rms);
}


//______________________________________________________________________________
void TGraph::InitExpo(Double_t xmin, Double_t xmax)
{
   // Compute Initial values of parameters for an exponential.

   Double_t constant, slope;
   Int_t ifail;
   if (xmax <= xmin) {xmin = fX[0]; xmax = fX[fNpoints-1];}
   Int_t nchanx = fNpoints;

   LeastSquareLinearFit(-nchanx, constant, slope, ifail, xmin, xmax);

   TVirtualFitter *grFitter = TVirtualFitter::GetFitter();
   TF1 *f1 = (TF1*)grFitter->GetUserFunc();
   f1->SetParameter(0,constant);
   f1->SetParameter(1,slope);
}


//______________________________________________________________________________
void TGraph::InitPolynom(Double_t xmin, Double_t xmax)
{
   // Compute Initial values of parameters for a polynom.

   Double_t fitpar[25];

   TVirtualFitter *grFitter = TVirtualFitter::GetFitter();
   TF1 *f1 = (TF1*)grFitter->GetUserFunc();
   Int_t npar   = f1->GetNpar();
   if (xmax <= xmin) {xmin = fX[0]; xmax = fX[fNpoints-1];}

   LeastSquareFit(npar, fitpar, xmin, xmax);

   for (Int_t i=0;i<npar;i++) f1->SetParameter(i, fitpar[i]);
}


//______________________________________________________________________________
Int_t TGraph::InsertPoint()
{
   // Insert a new point at the mouse position

   Int_t px = gPad->GetEventX();
   Int_t py = gPad->GetEventY();

   //localize point where to insert
   Int_t ipoint = -2;
   Int_t i,d=0;
   // start with a small window (in case the mouse is very close to one point)
   for (i=0;i<fNpoints-1;i++) {
      d = DistancetoLine(px, py, gPad->XtoPad(fX[i]), gPad->YtoPad(fY[i]), gPad->XtoPad(fX[i+1]), gPad->YtoPad(fY[i+1]));
      if (d < 5) {ipoint = i+1; break;}
   }
   if (ipoint == -2) {
      //may be we are far from one point, try again with a larger window
      for (i=0;i<fNpoints-1;i++) {
         d = DistancetoLine(px, py, gPad->XtoPad(fX[i]), gPad->YtoPad(fY[i]), gPad->XtoPad(fX[i+1]), gPad->YtoPad(fY[i+1]));
         if (d < 10) {ipoint = i+1; break;}
      }
   }
   if (ipoint == -2) {
      //distinguish between first and last point
      Int_t dpx = px - gPad->XtoAbsPixel(gPad->XtoPad(fX[0]));
      Int_t dpy = py - gPad->YtoAbsPixel(gPad->XtoPad(fY[0]));
      if (dpx*dpx+dpy*dpy < 25) ipoint = 0;
      else                      ipoint = fNpoints;
   }
   Double_t **ps = ExpandAndCopy(fNpoints + 1, ipoint);
   CopyAndRelease(ps, ipoint, fNpoints++, ipoint + 1);

   // To avoid redefenitions in descendant classes
   FillZero(ipoint, ipoint + 1);

   fX[ipoint] = gPad->PadtoX(gPad->AbsPixeltoX(px));
   fY[ipoint] = gPad->PadtoY(gPad->AbsPixeltoY(py));
   gPad->Modified();
   return ipoint;
}

//______________________________________________________________________________
Double_t TGraph::Integral(Int_t first, Int_t last) const
{
   // Integrate the TGraph data within a given (index) range
   // NB: if last=-1 (default) last is set to the last point.
   //     if (first <0) the first point (0) is taken.
   //   : The graph segments should not intersect.
   //Method:
   // There are many ways to calculate the surface of a polygon. It all depends on what kind of data
   // you have to deal with. The most evident solution would be to divide the polygon in triangles and
   // calculate the surface of them. But this can quickly become complicated as you will have to test
   // every segments of every triangles and check if they are intersecting with a current polygon's
   // segment or if it goes outside the polygon. Many calculations that would lead to many problems...
   //      The solution (implemented by R.Brun)
   // Fortunately for us, there is a simple way to solve this problem, as long as the polygon's
   // segments don't intersect.
   // It takes the x coordinate of the current vertex and multiply it by the y coordinate of the next
   // vertex. Then it subtracts from it the result of the y coordinate of the current vertex multiplied
   // by the x coordinate of the next vertex. Then divide the result by 2 to get the surface/area.
   //      Sources
   //      http://forums.wolfram.com/mathgroup/archive/1998/Mar/msg00462.html
   //      http://stackoverflow.com/questions/451426/how-do-i-calculate-the-surface-area-of-a-2d-polygon

   if (first < 0) first = 0;
   if (last < 0) last = fNpoints-1;
   if(last >= fNpoints) last = fNpoints-1;
   if (first >= last) return 0;
   Int_t np = last-first+1;
   Double_t sum = 0.0;
   for(Int_t i=first;i<=last;i++) {
      Int_t j = first + (i-first+1)%np;
      sum += TMath::Abs(fX[i]*fY[j]);
      sum -= TMath::Abs(fY[i]*fX[j]);
   }
   return 0.5*sum;
}


//______________________________________________________________________________
void TGraph::LeastSquareFit(Int_t m, Double_t *a, Double_t xmin, Double_t xmax)
{
   // Least squares polynomial fitting without weights.
   //
   //  m     number of parameters
   //  a     array of parameters
   //  first 1st point number to fit (default =0)
   //  last  last point number to fit (default=fNpoints-1)
   //
   //   based on CERNLIB routine LSQ: Translated to C++ by Rene Brun

   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;
   Int_t n = fNpoints;
   if (xmax <= xmin) {xmin = fX[0]; xmax = fX[fNpoints-1];}

   if (m <= 2) {
      LeastSquareLinearFit(n, a[0], a[1], ifail, xmin, xmax);
      return;
   }
   if (m > idim || m > n) return;
   da[0] = zero;
   for (l = 2; l <= m; ++l) {
      b[l-1]           = zero;
      b[m + l*20 - 21] = zero;
      da[l-1]          = zero;
   }
   Int_t np = 0;
   for (k = 0; k < fNpoints; ++k) {
      xk     = fX[k];
      if (xk < xmin || xk > xmax) continue;
      np++;
      yk     = fY[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;
      }
   }
   b[0]  = Double_t(np);
   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);

   if (ifail < 0) {
      a[0] = fY[0];
      for (i=1; i<m; ++i) a[i] = 0;
      return;
   }
   for (i=0; i<m; ++i) a[i] = da[i];
}


//______________________________________________________________________________
void TGraph::LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double_t &a1, Int_t &ifail, Double_t xmin, Double_t xmax)
{
   // Least square linear fit without weights.
   //
   //  Fit a straight line (a0 + a1*x) to the data in this graph.
   //  ndata:  if ndata<0, fits the logarithm of the graph (used in InitExpo() to set
   //          the initial parameter values for a fit with exponential function.
   //  a0:     constant
   //  a1:     slope
   //  ifail:  return parameter indicating the status of the fit (ifail=0, fit is OK)
   //  xmin, xmax: fitting range
   //
   //  extracted from CERNLIB LLSQ: Translated to C++ by Rene Brun

   Double_t xbar, ybar, x2bar;
   Int_t i;
   Double_t xybar;
   Double_t fn, xk, yk;
   Double_t det;
   if (xmax <= xmin) {xmin = fX[0]; xmax = fX[fNpoints-1];}

   ifail = -2;
   xbar  = ybar = x2bar = xybar = 0;
   Int_t np = 0;
   for (i = 0; i < fNpoints; ++i) {
      xk = fX[i];
      if (xk < xmin || xk > xmax) continue;
      np++;
      yk = fY[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(np);
   det   = fn*x2bar - xbar*xbar;
   ifail = -1;
   if (det <= 0) {
      if (fn > 0) a0 = ybar/fn;
      else        a0 = 0;
      a1 = 0;
      return;
   }
   ifail = 0;
   a0 = (x2bar*ybar - xbar*xybar) / det;
   a1 = (fn*xybar - xbar*ybar) / det;
}


//______________________________________________________________________________
void TGraph::Paint(Option_t *option)
{
   // Draw this graph with its current attributes.

   TVirtualGraphPainter::GetPainter()->PaintHelper(this, option);
}


//______________________________________________________________________________
void TGraph::PaintGraph(Int_t npoints, const Double_t *x, const Double_t *y, Option_t *chopt)
{
   // Draw the (x,y) as a graph.

   TVirtualGraphPainter::GetPainter()->PaintGraph(this, npoints, x, y, chopt);
}


//______________________________________________________________________________
void TGraph::PaintGrapHist(Int_t npoints, const Double_t *x, const Double_t *y, Option_t *chopt)
{
   // Draw the (x,y) as a histogram.

   TVirtualGraphPainter::GetPainter()->PaintGrapHist(this, npoints, x, y, chopt);
}


//______________________________________________________________________________
void TGraph::PaintStats(TF1 *fit)
{
   // Draw the stats

   TVirtualGraphPainter::GetPainter()->PaintStats(this, fit);
}


//______________________________________________________________________________
void TGraph::Print(Option_t *) const
{
   // Print graph values.

   for (Int_t i=0;i<fNpoints;i++) {
      printf("x[%d]=%g, y[%d]=%g\n",i,fX[i],i,fY[i]);
   }
}


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

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


//______________________________________________________________________________
Int_t TGraph::RemovePoint()
{
   // Delete point close to the mouse position

   Int_t px = gPad->GetEventX();
   Int_t py = gPad->GetEventY();

   //localize point to be deleted
   Int_t ipoint = -2;
   Int_t i;
   // start with a small window (in case the mouse is very close to one point)
   for (i=0;i<fNpoints;i++) {
      Int_t dpx = px - gPad->XtoAbsPixel(gPad->XtoPad(fX[i]));
      Int_t dpy = py - gPad->YtoAbsPixel(gPad->YtoPad(fY[i]));
      if (dpx*dpx+dpy*dpy < 100) {ipoint = i; break;}
   }
   return RemovePoint(ipoint);
}


//______________________________________________________________________________
Int_t TGraph::RemovePoint(Int_t ipoint)
{
   // Delete point number ipoint

   if (ipoint < 0) return -1;
   if (ipoint >= fNpoints) return -1;

   Double_t **ps = ShrinkAndCopy(fNpoints - 1, ipoint);
   CopyAndRelease(ps, ipoint+1, fNpoints--, ipoint);
   if (gPad) gPad->Modified();
   return ipoint;
}


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

   char quote = '"';
   out<<"   "<<endl;
   if (gROOT->ClassSaved(TGraph::Class())) {
      out<<"   ";
   } else {
      out<<"   TGraph *";
   }
   out<<"graph = new TGraph("<<fNpoints<<");"<<endl;
   out<<"   graph->SetName("<<quote<<GetName()<<quote<<");"<<endl;
   out<<"   graph->SetTitle("<<quote<<GetTitle()<<quote<<");"<<endl;

   SaveFillAttributes(out,"graph",0,1001);
   SaveLineAttributes(out,"graph",1,1,1);
   SaveMarkerAttributes(out,"graph",1,1,1);

   for (Int_t i=0;i<fNpoints;i++) {
      out<<"   graph->SetPoint("<<i<<","<<fX[i]<<","<<fY[i]<<");"<<endl;
   }

   static Int_t frameNumber = 0;
   if (fHistogram) {
      frameNumber++;
      TString hname = fHistogram->GetName();
      hname += frameNumber;
      fHistogram->SetName(hname.Data());
      fHistogram->SavePrimitive(out,"nodraw");
      out<<"   graph->SetHistogram("<<fHistogram->GetName()<<");"<<endl;
      out<<"   "<<endl;
   }

   // save list of functions
   TIter next(fFunctions);
   TObject *obj;
   while ((obj=next())) {
      obj->SavePrimitive(out,"nodraw");
      if (obj->InheritsFrom("TPaveStats")) {
         out<<"   graph->GetListOfFunctions()->Add(ptstats);"<<endl;
         out<<"   ptstats->SetParent(graph->GetListOfFunctions());"<<endl;
      } else {
         out<<"   graph->GetListOfFunctions()->Add("<<obj->GetName()<<");"<<endl;
      }
   }

   const char *l = strstr(option,"multigraph");
   if (l) {
      out<<"   multigraph->Add(graph,"<<quote<<l+10<<quote<<");"<<endl;
   } else {
      out<<"   graph->Draw("<<quote<<option<<quote<<");"<<endl;
   }
}


//______________________________________________________________________________
void TGraph::Set(Int_t n)
{
   // Set number of points in the graph
   // Existing coordinates are preserved
   // New coordinates above fNpoints are preset to 0.

   if (n < 0) n = 0;
   if (n == fNpoints) return;
   Double_t **ps = Allocate(n);
   CopyAndRelease(ps, 0, TMath::Min(fNpoints,n), 0);
   if (n > fNpoints) {
      FillZero(fNpoints, n, kFALSE);
   }
   fNpoints = n;
}


//______________________________________________________________________________
Bool_t TGraph::GetEditable() const
{
   // Return kTRUE if kNotEditable bit is not set, kFALSE otherwise.

   return TestBit(kNotEditable) ? kFALSE : kTRUE;
}


//______________________________________________________________________________
void TGraph::SetEditable(Bool_t editable)
{
   // if editable=kFALSE, the graph cannot be modified with the mouse
   //  by default a TGraph is editable

   if (editable) ResetBit(kNotEditable);
   else          SetBit(kNotEditable);
}


//______________________________________________________________________________
void TGraph::SetMaximum(Double_t maximum)
{
   // Set the maximum of the graph.

   fMaximum = maximum;
   GetHistogram()->SetMaximum(maximum);
}


//______________________________________________________________________________
void TGraph::SetMinimum(Double_t minimum)
{
   // Set the minimum of the graph.

   fMinimum = minimum;
   GetHistogram()->SetMinimum(minimum);
}


//______________________________________________________________________________
void TGraph::SetPoint(Int_t i, Double_t x, Double_t y)
{
   // Set x and y values for point number i.

   if (i < 0) return;
   if (fHistogram) {
      delete fHistogram;
      fHistogram = 0;
   }
   if (i >= fMaxSize) {
      Double_t **ps = ExpandAndCopy(i+1, fNpoints);
      CopyAndRelease(ps, 0,0,0);
   }
   if (i >= fNpoints) {
      // points above i can be not initialized
      // set zero up to i-th point to avoid redefenition
      // of this method in descendant classes
      FillZero(fNpoints, i + 1);
      fNpoints = i+1;
   }
   fX[i] = x;
   fY[i] = y;
   if (gPad) gPad->Modified();
}


//______________________________________________________________________________
void TGraph::SetTitle(const char* title)
{
   // Set graph title.

   fTitle = title;
   if (fHistogram) fHistogram->SetTitle(title);
}


//______________________________________________________________________________
Double_t **TGraph::ShrinkAndCopy(Int_t size, Int_t oend)
{
   // if size*2 <= fMaxSize allocate new arrays of size points,
   // copy points [0,oend).
   // Return newarray (passed or new instance if it was zero
   // and allocations are needed)
   if (size*2 > fMaxSize || !fMaxSize) {
      return 0;
   }
   Double_t **newarrays = Allocate(size);
   CopyPoints(newarrays, 0, oend, 0);
   return newarrays;
}


//______________________________________________________________________________
void TGraph::Sort(Bool_t (*greaterfunc)(const TGraph*, Int_t, Int_t) /*=TGraph::CompareX()*/,
                  Bool_t ascending /*=kTRUE*/, Int_t low /* =0 */, Int_t high /* =-1111 */)
{
   // Sorts the points of this TGraph using in-place quicksort (see e.g. older glibc).
   // To compare two points the function parameter greaterfunc is used (see TGraph::CompareX for an
   // example of such a method, which is also the default comparison function for Sort). After
   // the sort, greaterfunc(this, i, j) will return kTRUE for all i>j if ascending == kTRUE, and
   // kFALSE otherwise.
   //
   // The last two parameters are used for the recursive quick sort, stating the range to be sorted
   //
   // Examples:
   //   // sort points along x axis
   //   graph->Sort();
   //   // sort points along their distance to origin
   //   graph->Sort(&TGraph::CompareRadius);
   //
   //   Bool_t CompareErrors(const TGraph* gr, Int_t i, Int_t j) {
   //     const TGraphErrors* ge=(const TGraphErrors*)gr;
   //     return (ge->GetEY()[i]>ge->GetEY()[j]); }
   //   // sort using the above comparison function, largest errors first
   //   graph->Sort(&CompareErrors, kFALSE);

   if (high == -1111) high = GetN()-1;
   //  Termination condition
   if (high <= low) return;

   int left, right;
   left = low; // low is the pivot element
   right = high;
   while (left < right) {
      // move left while item < pivot
      while(left <= high && greaterfunc(this, left, low) != ascending)
         left++;
      // move right while item > pivot
      while(right > low && greaterfunc(this, right, low) == ascending)
         right--;
      if (left < right && left < high && right > low)
         SwapPoints(left, right);
   }
   // right is final position for the pivot
   if (right > low)
      SwapPoints(low, right);
   Sort( greaterfunc, ascending, low, right-1 );
   Sort( greaterfunc, ascending, right+1, high );
}


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

   if (b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = b.ReadVersion(&R__s, &R__c);
      if (R__v > 2) {
         b.ReadClassBuffer(TGraph::Class(), this, R__v, R__s, R__c);
         if (fHistogram) fHistogram->SetDirectory(0);
         TIter next(fFunctions);
         TObject *obj;
         while ((obj = next())) {
            if (obj->InheritsFrom(TF1::Class())) {
               TF1 *f1 = (TF1*)obj;
               f1->SetParent(this);
            }
         }
         fMaxSize = fNpoints;
         return;
      }
      //====process old versions before automatic schema evolution
      TNamed::Streamer(b);
      TAttLine::Streamer(b);
      TAttFill::Streamer(b);
      TAttMarker::Streamer(b);
      b >> fNpoints;
      fMaxSize = fNpoints;
      fX = new Double_t[fNpoints];
      fY = new Double_t[fNpoints];
      if (R__v < 2) {
         Float_t *x = new Float_t[fNpoints];
         Float_t *y = new Float_t[fNpoints];
         b.ReadFastArray(x,fNpoints);
         b.ReadFastArray(y,fNpoints);
         for (Int_t i=0;i<fNpoints;i++) {
            fX[i] = x[i];
            fY[i] = y[i];
         }
         delete [] y;
         delete [] x;
      } else {
         b.ReadFastArray(fX,fNpoints);
         b.ReadFastArray(fY,fNpoints);
      }
      b >> fFunctions;
      b >> fHistogram;
      if (fHistogram) fHistogram->SetDirectory(0);
      if (R__v < 2) {
         Float_t mi,ma;
         b >> mi;
         b >> ma;
         fMinimum = mi;
         fMaximum = ma;
      } else {
         b >> fMinimum;
         b >> fMaximum;
      }
      b.CheckByteCount(R__s, R__c, TGraph::IsA());
      //====end of old versions

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


//______________________________________________________________________________
void TGraph::SwapPoints(Int_t pos1, Int_t pos2)
{
   // Swap points.

   SwapValues(fX, pos1, pos2);
   SwapValues(fY, pos1, pos2);
}


//______________________________________________________________________________
void TGraph::SwapValues(Double_t* arr, Int_t pos1, Int_t pos2)
{
   // Swap values.

   Double_t tmp=arr[pos1];
   arr[pos1]=arr[pos2];
   arr[pos2]=tmp;
}


//______________________________________________________________________________
void TGraph::UseCurrentStyle()
{
   // Set current style settings in this graph
   // This function is called when either TCanvas::UseCurrentStyle
   // or TROOT::ForceStyle have been invoked.

   if (gStyle->IsReading()) {
      SetFillColor(gStyle->GetHistFillColor());
      SetFillStyle(gStyle->GetHistFillStyle());
      SetLineColor(gStyle->GetHistLineColor());
      SetLineStyle(gStyle->GetHistLineStyle());
      SetLineWidth(gStyle->GetHistLineWidth());
      SetMarkerColor(gStyle->GetMarkerColor());
      SetMarkerStyle(gStyle->GetMarkerStyle());
      SetMarkerSize(gStyle->GetMarkerSize());
   } else {
      gStyle->SetHistFillColor(GetFillColor());
      gStyle->SetHistFillStyle(GetFillStyle());
      gStyle->SetHistLineColor(GetLineColor());
      gStyle->SetHistLineStyle(GetLineStyle());
      gStyle->SetHistLineWidth(GetLineWidth());
      gStyle->SetMarkerColor(GetMarkerColor());
      gStyle->SetMarkerStyle(GetMarkerStyle());
      gStyle->SetMarkerSize(GetMarkerSize());
   }
   if (fHistogram) fHistogram->UseCurrentStyle();

   TIter next(GetListOfFunctions());
   TObject *obj;

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


//______________________________________________________________________________
Int_t TGraph::Merge(TCollection* li)
{
   // Adds all graphs from the collection to this graph.
   // Returns the total number of poins in the result or -1 in case of an error.

   TIter next(li);
   while (TObject* o = next()) {
      TGraph *g = dynamic_cast<TGraph*> (o);
      if (!g) {
         Error("Merge",
             "Cannot merge - an object which doesn't inherit from TGraph found in the list");
         return -1;
      }
      Double_t x, y;
      for (Int_t i = 0 ; i < g->GetN(); i++) {
         g->GetPoint(i, x, y);
         SetPoint(GetN(), x, y);
      }
   }
   return GetN();
}


//______________________________________________________________________________
void TGraph::Zero(Int_t &k,Double_t AZ,Double_t BZ,Double_t E2,Double_t &X,Double_t &Y
                 ,Int_t maxiterations)
{
   // Find zero of a continuous function.
   // This function finds a real zero of the continuous real
   // function Y(X) in a given interval (A,B). See accompanying
   // notes for details of the argument list and calling sequence

   static Double_t a, b, ya, ytest, y1, x1, h;
   static Int_t j1, it, j3, j2;
   Double_t yb, x2;
   yb = 0;

   //       Calculate Y(X) at X=AZ.
   if (k <= 0) {
      a  = AZ;
      b  = BZ;
      X  = a;
      j1 = 1;
      it = 1;
      k  = j1;
      return;
   }

   //       Test whether Y(X) is sufficiently small.

   if (TMath::Abs(Y) <= E2) { k = 2; return; }

   //       Calculate Y(X) at X=BZ.

   if (j1 == 1) {
      ya = Y;
      X  = b;
      j1 = 2;
      return;
   }
   //       Test whether the signs of Y(AZ) and Y(BZ) are different.
   //       if not, begin the binary subdivision.

   if (j1 != 2) goto L100;
   if (ya*Y < 0) goto L120;
   x1 = a;
   y1 = ya;
   j1 = 3;
   h  = b - a;
   j2 = 1;
   x2 = a + 0.5*h;
   j3 = 1;
   it++;      //*-*-   Check whether (maxiterations) function values have been calculated.
   if (it >= maxiterations) k = j1;
   else                     X = x2;
   return;

   //      Test whether a bracket has been found .
   //      If not,continue the search

L100:
   if (j1 > 3) goto L170;
   if (ya*Y >= 0) {
      if (j3 >= j2) {
         h  = 0.5*h; j2 = 2*j2;
         a  = x1;  ya = y1;  x2 = a + 0.5*h; j3 = 1;
      }
      else {
         a  = X;   ya = Y;   x2 = X + h;     j3++;
      }
      it++;
      if (it >= maxiterations) k = j1;
      else                     X = x2;
      return;
   }

   //       The first bracket has been found.calculate the next X by the
   //       secant method based on the bracket.

L120:
   b  = X;
   yb = Y;
   j1 = 4;
L130:
   if (TMath::Abs(ya) > TMath::Abs(yb)) { x1 = a; y1 = ya; X  = b; Y  = yb; }
   else                                 { x1 = b; y1 = yb; X  = a; Y  = ya; }

   //       Use the secant method based on the function values y1 and Y.
   //       check that x2 is inside the interval (a,b).

L150:
   x2    = X-Y*(X-x1)/(Y-y1);
   x1    = X;
   y1    = Y;
   ytest = 0.5*TMath::Min(TMath::Abs(ya),TMath::Abs(yb));
   if ((x2-a)*(x2-b) < 0) {
      it++;
      if (it >= maxiterations) k = j1;
      else                     X = x2;
      return;
   }

   //       Calculate the next value of X by bisection . Check whether
   //       the maximum accuracy has been achieved.

L160:
   x2    = 0.5*(a+b);
   ytest = 0;
   if ((x2-a)*(x2-b) >= 0) { k = 2;  return; }
   it++;
   if (it >= maxiterations) k = j1;
   else                     X = x2;
   return;


   //       Revise the bracket (a,b).

L170:
   if (j1 != 4) return;
   if (ya*Y < 0) { b  = X; yb = Y; }
   else          { a  = X; ya = Y; }

   //       Use ytest to decide the method for the next value of X.

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