ROOT logo
// @(#)root/hist:$Id$
// 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 "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 performed 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>
<i>Note:</i>Unlike histogram or tree (or even TGraph2D), TGraph objects
 are not automatically attached to the current TFile, in order to keep the
 management and size of the TGraph has small as possible.
</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
   if (!CtorAllocate()) return;
}


//______________________________________________________________________________
TGraph::TGraph(Int_t n)
   : TNamed("Graph", "Graph"), TAttLine(), TAttFill(1, 1001), TAttMarker()
{
   // Constructor with only the number of points set
   // the arrays 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;

      // delete list of functions and their contents before copying it
      if (fFunctions) {
         // delete previous lists of functions
         if (!fFunctions->IsEmpty()) {
            fFunctions->SetBit(kInvalidObject);
            // use TList::Remove to take into account the case the same object is
            // added multiple times in the list
            TObject *obj;
            while ((obj  = fFunctions->First())) {
               while (fFunctions->Remove(obj)) { }
               delete obj;
            }
         }
         delete fFunctions;
      }

      if (gr.fFunctions) fFunctions = (TList*)gr.fFunctions->Clone();
      else fFunctions = new TList;

      if (fHistogram) delete fHistogram;
      if (gr.fHistogram) fHistogram = new TH1F(*(gr.fHistogram));
      else fHistogram = 0;

      fMinimum = gr.fMinimum;
      fMaximum = gr.fMaximum;
      if (fX) delete [] fX;
      if (fY) delete [] fY;
      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;
      return;
   }
   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 *option)
   : 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".
   // this is a standard c formatting for scanf. If columns of numbers should be
   // skipped, a "%*lg" or "%*s" for each column can be added,
   // e.g. "%lg %*lg %lg" would read x-values from the first and y-values from
   // the third column.
   // For files separated by a specific delimiter different from ' ' and '\t' (e.g. ';' in csv files)
   // you can avoid using %*s to bypass this delimiter by explicitly specify the "option" argument,
   // e.g. option=" \t,;" for columns of figures separated by any of these characters (' ', '\t', ',', ';')
   // used once (e.g. "1;1") or in a combined way (" 1;,;;  1").
   // Note in that case, the instanciation is about 2 times slower.

   Double_t x, y;
   TString fname = filename;
   gSystem->ExpandPathName(fname);

   ifstream infile(fname.Data());
   if (!infile.good()) {
      MakeZombie();
      Error("TGraph", "Cannot open file: %s, TGraph is Zombie", filename);
      fNpoints = 0;
      return;
   } else {
      fNpoints = 100;  //initial number of points
   }
   if (!CtorAllocate()) return;
   std::string line;
   Int_t np = 0;

   // No delimiters specified (standard constructor).
   if (strcmp(option, "") == 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);

      // A delimiter has been specified in "option"
   } else {

      // Checking format and creating its boolean counterpart
      TString format_ = TString(format) ;
      format_.ReplaceAll(" ", "") ;
      format_.ReplaceAll("\t", "") ;
      format_.ReplaceAll("lg", "") ;
      format_.ReplaceAll("s", "") ;
      format_.ReplaceAll("%*", "0") ;
      format_.ReplaceAll("%", "1") ;
      if (!format_.IsDigit()) {
         Error("TGraph", "Incorrect input format! Allowed formats are {\"%%lg\",\"%%*lg\" or \"%%*s\"}");
         return;
      }
      Int_t ntokens = format_.Length() ;
      if (ntokens < 2) {
         Error("TGraph", "Incorrect input format! Only %d tag(s) in format whereas 2 \"%%lg\" tags are expected!", ntokens);
         return;
      }
      Int_t ntokensToBeSaved = 0 ;
      Bool_t * isTokenToBeSaved = new Bool_t [ntokens] ;
      for (Int_t idx = 0; idx < ntokens; idx++) {
         isTokenToBeSaved[idx] = TString::Format("%c", format_[idx]).Atoi() ; //atoi(&format_[idx]) does not work for some reason...
         if (isTokenToBeSaved[idx] == 1) {
            ntokensToBeSaved++ ;
         }
      }
      if (ntokens >= 2 && ntokensToBeSaved != 2) { //first condition not to repeat the previous error message
         Error("TGraph", "Incorrect input format! There are %d \"%%lg\" tag(s) in format whereas 2 and only 2 are expected!", ntokensToBeSaved);
         delete [] isTokenToBeSaved ;
         return;
      }

      // Initializing loop variables
      Bool_t isLineToBeSkipped = kFALSE ; //empty and ill-formed lines
      char * token = NULL ;
      TString token_str = "" ;
      Int_t token_idx = 0 ;
      Double_t * value = new Double_t [2] ; //x,y buffers
      Int_t value_idx = 0 ;

      // Looping
      while (std::getline(infile, line, '\n')) {
         if (line != "") {
            if (line[line.size() - 1] == char(13)) {  // removing DOS CR character
               line.erase(line.end() - 1, line.end()) ;
            }
            token = strtok(const_cast<char*>(line.c_str()), option) ;
            while (token != NULL && value_idx < 2) {
               if (isTokenToBeSaved[token_idx]) {
                  token_str = TString(token) ;
                  token_str.ReplaceAll("\t", "") ;
                  if (!token_str.IsFloat()) {
                     isLineToBeSkipped = kTRUE ;
                     break ;
                  } else {
                     value[value_idx] = token_str.Atof() ;
                     value_idx++ ;
                  }
               }
               token = strtok(NULL, option) ; //next token
               token_idx++ ;
            }
            if (!isLineToBeSkipped && value_idx == 2) {
               x = value[0] ;
               y = value[1] ;
               SetPoint(np, x, y) ;
               np++ ;
            }
         }
         isLineToBeSkipped = kFALSE ;
         token = NULL ;
         token_idx = 0 ;
         value_idx = 0 ;
      }
      Set(np) ;

      // Cleaning
      delete [] isTokenToBeSaved ;
      delete [] value ;
      delete token ;
   }
   infile.close();
}


//______________________________________________________________________________
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

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


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

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


//______________________________________________________________________________
Double_t TGraph::Chisquare(const TF1 *f1, Option_t * option) 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.
   // By default the range of the graph is used whatever function range.
   //  Use option "R" to use the function range

   // need to cast away the const - since it requires evaluating the function which is not const
   TF1 * func = const_cast<TF1*>(f1);
   if (!func) {
      Error("Chisquare","Function pointer is Null - return -1");
      return -1;
   }

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

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


//    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.
   //Note: This function should be called only from the constructor
   // since it does not delete previously existing arrays

   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 options 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 no option is specified, it is defined as "alp" in case there
   // no current pad or if the current pad as no axis defined.
   if (!strlen(option)) {
      if (gPad) {
         if (!gPad->GetListOfPrimitives()->FindObject("TFrame")) opt = "alp";
      } else {
         opt = "alp";
      }
   }

   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.

   TVirtualGraphPainter *painter = TVirtualGraphPainter::GetPainter();
   if (painter) return painter->DistancetoPrimitiveHelper(this, px, py);
   else return 0;
}


//______________________________________________________________________________
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 *painter = TVirtualGraphPainter::GetPainter();
   if (painter) painter->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;
         } else if (fX[i] > x) {
            if (up  == -1 || fX[i] < fX[up])  {
               up2 = up;
               up = i;
            } else if (up2 == -1) up2 = i;
         } else // case x == fX[i]
            return fY[i]; // no interpolation needed
      }

      // 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 *painter = TVirtualGraphPainter::GetPainter();
   if (painter) painter->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 or TGraphAsymErrors 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 TGraphErrors fit)
   //   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);
   //
   //
   // TGraphErrors fit:
   // =================
   //
   //   In case of a TGraphErrors object, when x errors are present, 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 then 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))
   //
   //   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->ParError(0); // retrieve the error for the parameter 0
   //  r->Print("V");     // print full information of fit including covariance matrix
   //  r->Write();        // store the result in a file
   //
   //  The fit parameters, error and chi2 (but not covariance matrix) can be retrieved also
   //  from the fitted function.
   //  If the histogram is made persistent, the list of
   //  associated functions is also persistent. Given a pointer (see above)
   //  to an associated function myfunc, one can retrieve the function/fit
   //  parameters with calls such as:
   //    Double_t chi2 = myfunc->GetChisquare();
   //    Double_t par0 = myfunc->GetParameter(0); //value of 1st parameter
   //    Double_t err0 = myfunc->GetParError(0);  //error on first parameter
   //
   //
   //  Access to the fit status
   //  =====================
   //  The status of the fit can be obtained converting the TFitResultPtr to an integer
   //  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.
   //
   // 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
   //

   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.
   TH1F *historg = 0;
   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;
      }
      historg = 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);
   // Restore the axis attributes if needed
   if (historg) {
      fHistogram->GetXaxis()->SetTitle(historg->GetXaxis()->GetTitle());
      fHistogram->GetXaxis()->CenterTitle(historg->GetXaxis()->GetCenterTitle());
      fHistogram->GetXaxis()->RotateTitle(historg->GetXaxis()->GetRotateTitle());
      fHistogram->GetXaxis()->SetNoExponent(historg->GetXaxis()->GetNoExponent());
      fHistogram->GetXaxis()->SetNdivisions(historg->GetXaxis()->GetNdivisions());
      fHistogram->GetXaxis()->SetLabelFont(historg->GetXaxis()->GetLabelFont());
      fHistogram->GetXaxis()->SetLabelOffset(historg->GetXaxis()->GetLabelOffset());
      fHistogram->GetXaxis()->SetLabelSize(historg->GetXaxis()->GetLabelSize());
      fHistogram->GetXaxis()->SetTitleSize(historg->GetXaxis()->GetTitleSize());
      fHistogram->GetXaxis()->SetTitleOffset(historg->GetXaxis()->GetTitleOffset());
      fHistogram->GetXaxis()->SetTitleFont(historg->GetXaxis()->GetTitleFont());

      fHistogram->GetYaxis()->SetTitle(historg->GetYaxis()->GetTitle());
      fHistogram->GetYaxis()->CenterTitle(historg->GetYaxis()->GetCenterTitle());
      fHistogram->GetYaxis()->RotateTitle(historg->GetYaxis()->GetRotateTitle());
      fHistogram->GetYaxis()->SetNoExponent(historg->GetYaxis()->GetNoExponent());
      fHistogram->GetYaxis()->SetNdivisions(historg->GetYaxis()->GetNdivisions());
      fHistogram->GetYaxis()->SetLabelFont(historg->GetYaxis()->GetLabelFont());
      fHistogram->GetYaxis()->SetLabelOffset(historg->GetYaxis()->GetLabelOffset());
      fHistogram->GetYaxis()->SetLabelSize(historg->GetYaxis()->GetLabelSize());
      fHistogram->GetYaxis()->SetTitleSize(historg->GetYaxis()->GetTitleSize());
      fHistogram->GetYaxis()->SetTitleOffset(historg->GetYaxis()->GetTitleOffset());
      fHistogram->GetYaxis()->SetTitleFont(historg->GetYaxis()->GetTitleFont());

      delete historg;
   }
   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
   // Note that this function computes the area of the polygon enclosed by the points of the TGraph.
   // The polygon segments, which are defined by the points of the TGraph, do not need to form a closed polygon,
   // since the last polygon segment, which closes the polygon, is taken as the line connecting the last TGraph point
   // with the first one. It is clear that the order of the point is essential in defining the polygon.
   // Also note that the segments should not intersect.
   //
   // NB: if last=-1 (default) last is set to the last point.
   //     if (first <0) the first point (0) is taken.
   //
   //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]);
   //}
   for (Int_t i = first; i <= last; i++) {
      Int_t j = first + (i - first + 1) % np;
      sum += (fY[i] + fY[j]) * (fX[j] - fX[i]);
   }
   return 0.5 * TMath::Abs(sum);
}


//______________________________________________________________________________
Int_t TGraph::IsInside(Double_t x, Double_t y) const
{
   // Return 1 if the point (x,y) is inside the polygon defined by
   // the graph vertices 0 otherwise.
   //
   // Algorithm:
   // The loop is executed with the end-point coordinates of a line segment
   // (X1,Y1)-(X2,Y2) and the Y-coordinate of a horizontal line.
   // The counter inter is incremented if the line (X1,Y1)-(X2,Y2) intersects
   // the horizontal line. In this case XINT is set to the X-coordinate of the
   // intersection point. If inter is an odd number, then the point x,y is within
   // the polygon.

   return (Int_t)TMath::IsInside(x, y, fNpoints, fX, fY);
}


//______________________________________________________________________________
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 *painter = TVirtualGraphPainter::GetPainter();
   if (painter) painter->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 *painter = TVirtualGraphPainter::GetPainter();
   if (painter) painter->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 *painter = TVirtualGraphPainter::GetPainter();
   if (painter) painter->PaintGrapHist(this, npoints, x, y, chopt);
}


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

   TVirtualGraphPainter *painter = TVirtualGraphPainter::GetPainter();
   if (painter) painter->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);
   }
   if (fHistogram == obj) fHistogram = 0;
}


//______________________________________________________________________________
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);

   if (fNpoints >= 1) {
      streamsize prec = out.precision();
      out.precision(10);
      for (Int_t i = 0; i < fNpoints; i++) {
         out << "   graph->SetPoint(" << i << "," << fX[i] << "," << fY[i] << ");" << endl;
      }
      out.precision(prec);
   }

   static Int_t frameNumber = 0;
   if (fHistogram) {
      frameNumber++;
      TString hname = fHistogram->GetName();
      hname += frameNumber;
      fHistogram->SetName(Form("Graph_%s", 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;
   l = strstr(option, "multigraph");
   if (l) {
      out << "   multigraph->Add(graph," << quote << l + 10 << quote << ");" << endl;
      return;
   }
   l = strstr(option, "th2poly");
   if (l) {
      out << "   " << l + 7 << "->AddBin(graph);" << endl;
      return;
   }
   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;
      }
      DoMerge(g);
   }
   return GetN();
}
//______________________________________________________________________________
Bool_t TGraph::DoMerge(const TGraph* g)
{
   //  protected function to perform the merge operation of a graph

   Double_t x, y;
   for (Int_t i = 0 ; i < g->GetN(); i++) {
      g->GetPoint(i, x, y);
      SetPoint(GetN(), x, y);
   }
   return kTRUE;
}
//______________________________________________________________________________
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
 TGraph.cxx:2339
 TGraph.cxx:2340
 TGraph.cxx:2341
 TGraph.cxx:2342
 TGraph.cxx:2343
 TGraph.cxx:2344
 TGraph.cxx:2345
 TGraph.cxx:2346
 TGraph.cxx:2347
 TGraph.cxx:2348
 TGraph.cxx:2349
 TGraph.cxx:2350
 TGraph.cxx:2351
 TGraph.cxx:2352
 TGraph.cxx:2353
 TGraph.cxx:2354
 TGraph.cxx:2355
 TGraph.cxx:2356
 TGraph.cxx:2357
 TGraph.cxx:2358
 TGraph.cxx:2359
 TGraph.cxx:2360
 TGraph.cxx:2361
 TGraph.cxx:2362
 TGraph.cxx:2363
 TGraph.cxx:2364
 TGraph.cxx:2365
 TGraph.cxx:2366
 TGraph.cxx:2367
 TGraph.cxx:2368
 TGraph.cxx:2369
 TGraph.cxx:2370
 TGraph.cxx:2371
 TGraph.cxx:2372
 TGraph.cxx:2373
 TGraph.cxx:2374
 TGraph.cxx:2375
 TGraph.cxx:2376
 TGraph.cxx:2377
 TGraph.cxx:2378
 TGraph.cxx:2379
 TGraph.cxx:2380
 TGraph.cxx:2381
 TGraph.cxx:2382
 TGraph.cxx:2383
 TGraph.cxx:2384
 TGraph.cxx:2385
 TGraph.cxx:2386
 TGraph.cxx:2387
 TGraph.cxx:2388
 TGraph.cxx:2389
 TGraph.cxx:2390
 TGraph.cxx:2391
 TGraph.cxx:2392
 TGraph.cxx:2393
 TGraph.cxx:2394
 TGraph.cxx:2395
 TGraph.cxx:2396
 TGraph.cxx:2397
 TGraph.cxx:2398
 TGraph.cxx:2399
 TGraph.cxx:2400
 TGraph.cxx:2401
 TGraph.cxx:2402
 TGraph.cxx:2403
 TGraph.cxx:2404
 TGraph.cxx:2405
 TGraph.cxx:2406
 TGraph.cxx:2407
 TGraph.cxx:2408
 TGraph.cxx:2409
 TGraph.cxx:2410
 TGraph.cxx:2411
 TGraph.cxx:2412
 TGraph.cxx:2413
 TGraph.cxx:2414
 TGraph.cxx:2415
 TGraph.cxx:2416
 TGraph.cxx:2417
 TGraph.cxx:2418
 TGraph.cxx:2419
 TGraph.cxx:2420
 TGraph.cxx:2421
 TGraph.cxx:2422
 TGraph.cxx:2423
 TGraph.cxx:2424
 TGraph.cxx:2425
 TGraph.cxx:2426
 TGraph.cxx:2427
 TGraph.cxx:2428
 TGraph.cxx:2429
 TGraph.cxx:2430
 TGraph.cxx:2431
 TGraph.cxx:2432
 TGraph.cxx:2433
 TGraph.cxx:2434
 TGraph.cxx:2435
 TGraph.cxx:2436
 TGraph.cxx:2437
 TGraph.cxx:2438
 TGraph.cxx:2439
 TGraph.cxx:2440
 TGraph.cxx:2441
 TGraph.cxx:2442
 TGraph.cxx:2443
 TGraph.cxx:2444
 TGraph.cxx:2445
 TGraph.cxx:2446
 TGraph.cxx:2447
 TGraph.cxx:2448
 TGraph.cxx:2449
 TGraph.cxx:2450
 TGraph.cxx:2451
 TGraph.cxx:2452
 TGraph.cxx:2453
 TGraph.cxx:2454
 TGraph.cxx:2455
 TGraph.cxx:2456
 TGraph.cxx:2457
 TGraph.cxx:2458
 TGraph.cxx:2459
 TGraph.cxx:2460
 TGraph.cxx:2461
 TGraph.cxx:2462
 TGraph.cxx:2463
 TGraph.cxx:2464
 TGraph.cxx:2465
 TGraph.cxx:2466
 TGraph.cxx:2467
 TGraph.cxx:2468
 TGraph.cxx:2469
 TGraph.cxx:2470
 TGraph.cxx:2471
 TGraph.cxx:2472
 TGraph.cxx:2473
 TGraph.cxx:2474
 TGraph.cxx:2475
 TGraph.cxx:2476
 TGraph.cxx:2477
 TGraph.cxx:2478
 TGraph.cxx:2479
 TGraph.cxx:2480
 TGraph.cxx:2481
 TGraph.cxx:2482
 TGraph.cxx:2483
 TGraph.cxx:2484
 TGraph.cxx:2485
 TGraph.cxx:2486
 TGraph.cxx:2487
 TGraph.cxx:2488
 TGraph.cxx:2489
 TGraph.cxx:2490
 TGraph.cxx:2491
 TGraph.cxx:2492
 TGraph.cxx:2493
 TGraph.cxx:2494
 TGraph.cxx:2495
 TGraph.cxx:2496
 TGraph.cxx:2497
 TGraph.cxx:2498
 TGraph.cxx:2499
 TGraph.cxx:2500
 TGraph.cxx:2501
 TGraph.cxx:2502
 TGraph.cxx:2503
 TGraph.cxx:2504
 TGraph.cxx:2505
 TGraph.cxx:2506
 TGraph.cxx:2507
 TGraph.cxx:2508
 TGraph.cxx:2509
 TGraph.cxx:2510
 TGraph.cxx:2511
 TGraph.cxx:2512
 TGraph.cxx:2513
 TGraph.cxx:2514
 TGraph.cxx:2515
 TGraph.cxx:2516
 TGraph.cxx:2517
 TGraph.cxx:2518
 TGraph.cxx:2519
 TGraph.cxx:2520
 TGraph.cxx:2521
 TGraph.cxx:2522
 TGraph.cxx:2523
 TGraph.cxx:2524
 TGraph.cxx:2525
 TGraph.cxx:2526
 TGraph.cxx:2527
 TGraph.cxx:2528
 TGraph.cxx:2529
 TGraph.cxx:2530
 TGraph.cxx:2531
 TGraph.cxx:2532
 TGraph.cxx:2533
 TGraph.cxx:2534
 TGraph.cxx:2535
 TGraph.cxx:2536
 TGraph.cxx:2537
 TGraph.cxx:2538
 TGraph.cxx:2539
 TGraph.cxx:2540
 TGraph.cxx:2541
 TGraph.cxx:2542
 TGraph.cxx:2543
 TGraph.cxx:2544
 TGraph.cxx:2545
 TGraph.cxx:2546
 TGraph.cxx:2547
 TGraph.cxx:2548
 TGraph.cxx:2549
 TGraph.cxx:2550
 TGraph.cxx:2551
 TGraph.cxx:2552
 TGraph.cxx:2553
 TGraph.cxx:2554
 TGraph.cxx:2555
 TGraph.cxx:2556
 TGraph.cxx:2557
 TGraph.cxx:2558
 TGraph.cxx:2559
 TGraph.cxx:2560
 TGraph.cxx:2561
 TGraph.cxx:2562
 TGraph.cxx:2563
 TGraph.cxx:2564
 TGraph.cxx:2565
 TGraph.cxx:2566
 TGraph.cxx:2567
 TGraph.cxx:2568
 TGraph.cxx:2569
 TGraph.cxx:2570
 TGraph.cxx:2571
 TGraph.cxx:2572
 TGraph.cxx:2573
 TGraph.cxx:2574
 TGraph.cxx:2575
 TGraph.cxx:2576
 TGraph.cxx:2577
 TGraph.cxx:2578
 TGraph.cxx:2579
 TGraph.cxx:2580
 TGraph.cxx:2581
 TGraph.cxx:2582
 TGraph.cxx:2583
 TGraph.cxx:2584
 TGraph.cxx:2585
 TGraph.cxx:2586
 TGraph.cxx:2587
 TGraph.cxx:2588
 TGraph.cxx:2589
 TGraph.cxx:2590
 TGraph.cxx:2591
 TGraph.cxx:2592
 TGraph.cxx:2593
 TGraph.cxx:2594
 TGraph.cxx:2595
 TGraph.cxx:2596
 TGraph.cxx:2597
 TGraph.cxx:2598
 TGraph.cxx:2599
 TGraph.cxx:2600
 TGraph.cxx:2601
 TGraph.cxx:2602
 TGraph.cxx:2603
 TGraph.cxx:2604
 TGraph.cxx:2605
 TGraph.cxx:2606
 TGraph.cxx:2607
 TGraph.cxx:2608
 TGraph.cxx:2609
 TGraph.cxx:2610
 TGraph.cxx:2611
 TGraph.cxx:2612
 TGraph.cxx:2613
 TGraph.cxx:2614
 TGraph.cxx:2615
 TGraph.cxx:2616
 TGraph.cxx:2617
 TGraph.cxx:2618
 TGraph.cxx:2619
 TGraph.cxx:2620
 TGraph.cxx:2621
 TGraph.cxx:2622
 TGraph.cxx:2623
 TGraph.cxx:2624
 TGraph.cxx:2625
 TGraph.cxx:2626
 TGraph.cxx:2627
 TGraph.cxx:2628
 TGraph.cxx:2629
 TGraph.cxx:2630
 TGraph.cxx:2631
 TGraph.cxx:2632
 TGraph.cxx:2633
 TGraph.cxx:2634
 TGraph.cxx:2635
 TGraph.cxx:2636
 TGraph.cxx:2637
 TGraph.cxx:2638
 TGraph.cxx:2639
 TGraph.cxx:2640
 TGraph.cxx:2641
 TGraph.cxx:2642
 TGraph.cxx:2643
 TGraph.cxx:2644
 TGraph.cxx:2645
 TGraph.cxx:2646
 TGraph.cxx:2647
 TGraph.cxx:2648