ROOT logo
// @(#)root/mathcore:$Id: TMath.cxx 36817 2010-11-21 08:36:19Z brun $
// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers   29/07/95

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TMath                                                                //
//                                                                      //
// Encapsulate math routines.                                           //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TMath.h"
#include "TError.h"
#include <math.h>
#include <string.h>
#include <algorithm>
#include "Riostream.h"
#include "TString.h"

#include <Math/SpecFuncMathCore.h>
#include <Math/PdfFuncMathCore.h>
#include <Math/ProbFuncMathCore.h>

//const Double_t
//   TMath::Pi = 3.14159265358979323846,
//   TMath::E  = 2.7182818284590452354;


// Without this macro the THtml doc for TMath can not be generated
#if !defined(R__ALPHA) && !defined(R__SOLARIS) && !defined(R__ACC) && !defined(R__FBSD)
NamespaceImp(TMath)
#endif

namespace TMath {

   Double_t GamCf(Double_t a,Double_t x);
   Double_t GamSer(Double_t a,Double_t x);
   Double_t VavilovDenEval(Double_t rlam, Double_t *AC, Double_t *HC, Int_t itype);
   void VavilovSet(Double_t rkappa, Double_t beta2, Bool_t mode, Double_t *WCM, Double_t *AC, Double_t *HC, Int_t &itype, Int_t &npt);

}

//______________________________________________________________________________
Long_t TMath::Hypot(Long_t x, Long_t y)
{
   return (Long_t) (hypot((Double_t)x, (Double_t)y) + 0.5);
}

//______________________________________________________________________________
Double_t TMath::Hypot(Double_t x, Double_t y)
{
   return hypot(x, y);
}

//______________________________________________________________________________
Double_t TMath::ASinH(Double_t x)
{
#if defined(WIN32)
   if(x==0.0) return 0.0;
   Double_t ax = Abs(x);
   return log(x+ax*sqrt(1.+1./(ax*ax)));
#else
   return asinh(x);
#endif
}

//______________________________________________________________________________
Double_t TMath::ACosH(Double_t x)
{
#if defined(WIN32)
   if(x==0.0) return 0.0;
   Double_t ax = Abs(x);
   return log(x+ax*sqrt(1.-1./(ax*ax)));
#else
   return acosh(x);
#endif
}

//______________________________________________________________________________
Double_t TMath::ATanH(Double_t x)
{
#if defined(WIN32)
   return log((1+x)/(1-x))/2;
#else
   return atanh(x);
#endif
}

//______________________________________________________________________________
Double_t TMath::Log2(Double_t x)
{
   return log(x)/log(2.0);
}

//______________________________________________________________________________
Int_t TMath::Nint(Float_t x)
{
   // Round to nearest integer. Rounds half integers to the nearest
   // even integer.

   int i;
   if (x >= 0) {
      i = int(x + 0.5);
      if (x + 0.5 == Float_t(i) && i & 1) i--;
   } else {
      i = int(x - 0.5);
      if (x - 0.5 == Float_t(i) && i & 1) i++;

   }
   return i;
}

//______________________________________________________________________________
Int_t TMath::Nint(Double_t x)
{
   // Round to nearest integer. Rounds half integers to the nearest
   // even integer.

   int i;
   if (x >= 0) {
      i = int(x + 0.5);
      if (x + 0.5 == Double_t(i) && i & 1) i--;
   } else {
      i = int(x - 0.5);
      if (x - 0.5 == Double_t(i) && i & 1) i++;

   }
   return i;
}

//______________________________________________________________________________
Double_t TMath::DiLog(Double_t x)
{
   // The DiLogarithm function
   // Code translated by R.Brun from CERNLIB DILOG function C332

   const Double_t hf  = 0.5;
   const Double_t pi  = TMath::Pi();
   const Double_t pi2 = pi*pi;
   const Double_t pi3 = pi2/3;
   const Double_t pi6 = pi2/6;
   const Double_t pi12 = pi2/12;
   const Double_t c[20] = {0.42996693560813697, 0.40975987533077105,
     -0.01858843665014592, 0.00145751084062268,-0.00014304184442340,
      0.00001588415541880,-0.00000190784959387, 0.00000024195180854,
     -0.00000003193341274, 0.00000000434545063,-0.00000000060578480,
      0.00000000008612098,-0.00000000001244332, 0.00000000000182256,
     -0.00000000000027007, 0.00000000000004042,-0.00000000000000610,
      0.00000000000000093,-0.00000000000000014, 0.00000000000000002};

   Double_t t,h,y,s,a,alfa,b1,b2,b0;

   if (x == 1) {
      h = pi6;
   } else if (x == -1) {
      h = -pi12;
   } else {
      t = -x;
      if (t <= -2) {
         y = -1/(1+t);
         s = 1;
         b1= TMath::Log(-t);
         b2= TMath::Log(1+1/t);
         a = -pi3+hf*(b1*b1-b2*b2);
      } else if (t < -1) {
         y = -1-t;
         s = -1;
         a = TMath::Log(-t);
         a = -pi6+a*(a+TMath::Log(1+1/t));
      } else if (t <= -0.5) {
         y = -(1+t)/t;
         s = 1;
         a = TMath::Log(-t);
         a = -pi6+a*(-hf*a+TMath::Log(1+t));
      } else if (t < 0) {
         y = -t/(1+t);
         s = -1;
         b1= TMath::Log(1+t);
         a = hf*b1*b1;
      } else if (t <= 1) {
         y = t;
         s = 1;
         a = 0;
      } else {
         y = 1/t;
         s = -1;
         b1= TMath::Log(t);
         a = pi6+hf*b1*b1;
      }
      h    = y+y-1;
      alfa = h+h;
      b1   = 0;
      b2   = 0;
      for (Int_t i=19;i>=0;i--){
         b0 = c[i] + alfa*b1-b2;
         b2 = b1;
         b1 = b0;
      }
      h = -(s*(b0-h*b2)+a);
   }
   return h;
}

//______________________________________________________________________________
Double_t TMath::Erf(Double_t x)
{
   // Computation of the error function erf(x).
   // Erf(x) = (2/sqrt(pi)) Integral(exp(-t^2))dt between 0 and x

   return ::ROOT::Math::erf(x);
}

//______________________________________________________________________________
Double_t TMath::Erfc(Double_t x)
{
   // Compute the complementary error function erfc(x).
   // Erfc(x) = (2/sqrt(pi)) Integral(exp(-t^2))dt between x and infinity
   //

   return ::ROOT::Math::erfc(x);
}

//______________________________________________________________________________
Double_t TMath::ErfInverse(Double_t x)
{
   // returns  the inverse error function
   // x must be  <-1<x<1

   Int_t kMaxit    = 50;
   Double_t kEps   = 1e-14;
   Double_t kConst = 0.8862269254527579;     // sqrt(pi)/2.0

   if(TMath::Abs(x) <= kEps) return kConst*x;

   // Newton iterations
   Double_t erfi, derfi, y0,y1,dy0,dy1;
   if(TMath::Abs(x) < 1.0) {
      erfi  = kConst*TMath::Abs(x);
      y0    = TMath::Erf(0.9*erfi);
      derfi = 0.1*erfi;
      for (Int_t iter=0; iter<kMaxit; iter++) {
         y1  = 1. - TMath::Erfc(erfi);
         dy1 = TMath::Abs(x) - y1;
         if (TMath::Abs(dy1) < kEps)  {if (x < 0) return -erfi; else return erfi;}
         dy0    = y1 - y0;
         derfi *= dy1/dy0;
         y0     = y1;
         erfi  += derfi;
         if(TMath::Abs(derfi/erfi) < kEps) {if (x < 0) return -erfi; else return erfi;}
      }
   }
   return 0; //did not converge
}
Double_t TMath::ErfcInverse(Double_t x)
{
   // returns  the inverse of the complementary error function
   // x must be  0<x<2
   // implement using  the quantile of the normal distribution
   // instead of ErfInverse for better numerical precision for large x 
   
   // erfc-1(x) = - 1/sqrt(2) * normal_quantile( 0.5 * x)
   return - 0.70710678118654752440 * TMath::NormQuantile( 0.5 * x); 
}
   



//______________________________________________________________________________
Double_t TMath::Factorial(Int_t n)
{
   // Compute factorial(n).

   if (n <= 0) return 1.;
   Double_t x = 1;
   Int_t b = 0;
   do {
      b++;
      x *= b;
   } while (b != n);
   return x;
}

//______________________________________________________________________________
Double_t TMath::Freq(Double_t x)
{
   // Computation of the normal frequency function freq(x).
   // Freq(x) = (1/sqrt(2pi)) Integral(exp(-t^2/2))dt between -infinity and x.
   //
   // Translated from CERNLIB C300 by Rene Brun.

   const Double_t c1 = 0.56418958354775629;
   const Double_t w2 = 1.41421356237309505;

   const Double_t p10 = 2.4266795523053175e+2,  q10 = 2.1505887586986120e+2,
                  p11 = 2.1979261618294152e+1,  q11 = 9.1164905404514901e+1,
                  p12 = 6.9963834886191355e+0,  q12 = 1.5082797630407787e+1,
                  p13 =-3.5609843701815385e-2,  q13 = 1;

   const Double_t p20 = 3.00459261020161601e+2, q20 = 3.00459260956983293e+2,
                  p21 = 4.51918953711872942e+2, q21 = 7.90950925327898027e+2,
                  p22 = 3.39320816734343687e+2, q22 = 9.31354094850609621e+2,
                  p23 = 1.52989285046940404e+2, q23 = 6.38980264465631167e+2,
                  p24 = 4.31622272220567353e+1, q24 = 2.77585444743987643e+2,
                  p25 = 7.21175825088309366e+0, q25 = 7.70001529352294730e+1,
                  p26 = 5.64195517478973971e-1, q26 = 1.27827273196294235e+1,
                  p27 =-1.36864857382716707e-7, q27 = 1;

   const Double_t p30 =-2.99610707703542174e-3, q30 = 1.06209230528467918e-2,
                  p31 =-4.94730910623250734e-2, q31 = 1.91308926107829841e-1,
                  p32 =-2.26956593539686930e-1, q32 = 1.05167510706793207e+0,
                  p33 =-2.78661308609647788e-1, q33 = 1.98733201817135256e+0,
                  p34 =-2.23192459734184686e-2, q34 = 1;

   Double_t v  = TMath::Abs(x)/w2;
   Double_t vv = v*v;
   Double_t ap, aq, h, hc, y;
   if (v < 0.5) {
      y=vv;
      ap=p13;
      aq=q13;
      ap = p12 +y*ap;
      ap = p11 +y*ap;
      ap = p10 +y*ap;
      aq = q12 +y*aq;
      aq = q11 +y*aq;
      aq = q10 +y*aq;
      h  = v*ap/aq;
      hc = 1-h;
   } else if (v < 4) {
      ap = p27;
      aq = q27;
      ap = p26 +v*ap;
      ap = p25 +v*ap;
      ap = p24 +v*ap;
      ap = p23 +v*ap;
      ap = p22 +v*ap;
      ap = p21 +v*ap;
      ap = p20 +v*ap;
      aq = q26 +v*aq;
      aq = q25 +v*aq;
      aq = q24 +v*aq;
      aq = q23 +v*aq;
      aq = q22 +v*aq;
      aq = q21 +v*aq;
      aq = q20 +v*aq;
      hc = TMath::Exp(-vv)*ap/aq;
      h  = 1-hc;
   } else {
      y  = 1/vv;
      ap = p34;
      aq = q34;
      ap = p33 +y*ap;
      ap = p32 +y*ap;
      ap = p31 +y*ap;
      ap = p30 +y*ap;
      aq = q33 +y*aq;
      aq = q32 +y*aq;
      aq = q31 +y*aq;
      aq = q30 +y*aq;
      hc = TMath::Exp(-vv)*(c1+y*ap/aq)/v;
      h  = 1-hc;
   }
   if (x > 0) return 0.5 +0.5*h;
   else return 0.5*hc;
}

//______________________________________________________________________________
Double_t TMath::Gamma(Double_t z)
{
   // Computation of gamma(z) for all z.
   //
   // C.Lanczos, SIAM Journal of Numerical Analysis B1 (1964), 86.
   //

   return ::ROOT::Math::tgamma(z);
}

//______________________________________________________________________________
Double_t TMath::Gamma(Double_t a,Double_t x)
{
   // Computation of the normalized lower incomplete gamma function P(a,x) as defined in the
   // Handbook of Mathematical Functions by Abramowitz and Stegun, formula 6.5.1 on page 260 .
   // Its normalization is such that TMath::Gamma(a,+infinity) = 1 .
   //
   //  Begin_Latex
   //  P(a, x) = #frac{1}{#Gamma(a) } #int_{0}^{x} t^{a-1} e^{-t} dt
   //   End_Latex
   //
   //
   //--- Nve 14-nov-1998 UU-SAP Utrecht

   return ::ROOT::Math::inc_gamma(a, x);
}

//______________________________________________________________________________
Double_t TMath::GamCf(Double_t a,Double_t x)
{
   // Computation of the incomplete gamma function P(a,x)
   // via its continued fraction representation.
   //
   //--- Nve 14-nov-1998 UU-SAP Utrecht

   Int_t itmax    = 100;      // Maximum number of iterations
   Double_t eps   = 3.e-14;   // Relative accuracy
   Double_t fpmin = 1.e-30;   // Smallest Double_t value allowed here

   if (a <= 0 || x <= 0) return 0;

   Double_t gln = LnGamma(a);
   Double_t b   = x+1-a;
   Double_t c   = 1/fpmin;
   Double_t d   = 1/b;
   Double_t h   = d;
   Double_t an,del;
   for (Int_t i=1; i<=itmax; i++) {
      an = Double_t(-i)*(Double_t(i)-a);
      b += 2;
      d  = an*d+b;
      if (Abs(d) < fpmin) d = fpmin;
      c = b+an/c;
      if (Abs(c) < fpmin) c = fpmin;
      d   = 1/d;
      del = d*c;
      h   = h*del;
      if (Abs(del-1) < eps) break;
      //if (i==itmax) cout << "*GamCf(a,x)* a too large or itmax too small" << endl;
   }
   Double_t v = Exp(-x+a*Log(x)-gln)*h;
   return (1-v);
}

//______________________________________________________________________________
Double_t TMath::GamSer(Double_t a,Double_t x)
{
   // Computation of the incomplete gamma function P(a,x)
   // via its series representation.
   //
   //--- Nve 14-nov-1998 UU-SAP Utrecht

   Int_t itmax  = 100;    // Maximum number of iterations
   Double_t eps = 3.e-14; // Relative accuracy

   if (a <= 0 || x <= 0) return 0;

   Double_t gln = LnGamma(a);
   Double_t ap  = a;
   Double_t sum = 1/a;
   Double_t del = sum;
   for (Int_t n=1; n<=itmax; n++) {
      ap  += 1;
      del  = del*x/ap;
      sum += del;
      if (TMath::Abs(del) < Abs(sum*eps)) break;
      //if (n==itmax) cout << "*GamSer(a,x)* a too large or itmax too small" << endl;
   }
   Double_t v = sum*Exp(-x+a*Log(x)-gln);
   return v;
}

//______________________________________________________________________________
Double_t TMath::BreitWigner(Double_t x, Double_t mean, Double_t gamma)
{
   // Calculate a Breit Wigner function with mean and gamma.

   Double_t bw = gamma/((x-mean)*(x-mean) + gamma*gamma/4);
   return bw/(2*Pi());
}

//______________________________________________________________________________
Double_t TMath::Gaus(Double_t x, Double_t mean, Double_t sigma, Bool_t norm)
{
   // Calculate a gaussian function with mean and sigma.
   // If norm=kTRUE (default is kFALSE) the result is divided
   // by sqrt(2*Pi)*sigma.

   if (sigma == 0) return 1.e30;
   Double_t arg = (x-mean)/sigma;
   Double_t res = TMath::Exp(-0.5*arg*arg);
   if (!norm) return res;
   return res/(2.50662827463100024*sigma); //sqrt(2*Pi)=2.50662827463100024
}

//______________________________________________________________________________
Double_t TMath::Landau(Double_t x, Double_t mpv, Double_t sigma, Bool_t norm)
{
   // The LANDAU function. 
   // mpv is a location parameter and correspond approximatly to the most probable value
   // and sigma is a scale parameter (not the sigma of the full distribution which is not defined)
   // Note that for mpv=0 and sigma=1 (default values) the exact location of the maximum of the distribution (most proble value) is at 
   // x = -0.22278
   // This function has been adapted from the CERNLIB routine G110 denlan.
   // If norm=kTRUE (default is kFALSE) the result is divided by sigma

   if (sigma <= 0) return 0; 
   Double_t den = ::ROOT::Math::landau_pdf( (x-mpv)/sigma ); 
   if (!norm) return den;
   return den/sigma;
}

//______________________________________________________________________________
Double_t TMath::LnGamma(Double_t z)
{
   // Computation of ln[gamma(z)] for all z.
   //
   // C.Lanczos, SIAM Journal of Numerical Analysis B1 (1964), 86.
   //
   // The accuracy of the result is better than 2e-10.
   //
   //--- Nve 14-nov-1998 UU-SAP Utrecht

   return ::ROOT::Math::lgamma(z);
}

//______________________________________________________________________________
Float_t TMath::Normalize(Float_t v[3])
{
   // Normalize a vector v in place.
   // Returns the norm of the original vector.

   Float_t d = Sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]);
   if (d != 0) {
      v[0] /= d;
      v[1] /= d;
      v[2] /= d;
   }
   return d;
}

//______________________________________________________________________________
Double_t TMath::Normalize(Double_t v[3])
{
   // Normalize a vector v in place.
   // Returns the norm of the original vector.
   // This implementation (thanks Kevin Lynch <krlynch@bu.edu>) is protected
   // against possible overflows.

   // Find the largest element, and divide that one out.

   Double_t av0 = Abs(v[0]), av1 = Abs(v[1]), av2 = Abs(v[2]);

   Double_t amax, foo, bar;
   // 0 >= {1, 2}
   if( av0 >= av1 && av0 >= av2 ) {
      amax = av0;
      foo = av1;
      bar = av2;
   }
   // 1 >= {0, 2}
   else if (av1 >= av0 && av1 >= av2) {
      amax = av1;
      foo = av0;
      bar = av2;
   }
   // 2 >= {0, 1}
   else {
      amax = av2;
      foo = av0;
      bar = av1;
   }

   if (amax == 0.0)
      return 0.;

   Double_t foofrac = foo/amax, barfrac = bar/amax;
   Double_t d = amax * Sqrt(1.+foofrac*foofrac+barfrac*barfrac);

   v[0] /= d;
   v[1] /= d;
   v[2] /= d;
   return d;
}

//______________________________________________________________________________
Double_t TMath::Poisson(Double_t x, Double_t par)
{
  // compute the Poisson distribution function for (x,par)
  // The Poisson PDF is implemented by means of Euler's Gamma-function
  // (for the factorial), so for all integer arguments it is correct.
  // BUT for non-integer values it IS NOT equal to the Poisson distribution.
  // see TMath::PoissonI to get a non-smooth function.
  // Note that for large values of par, it is better to call
  //     TMath::Gaus(x,par,sqrt(par),kTRUE)
//Begin_Html
/*
<img src="gif/Poisson.gif">
*/
//End_Html

   if (x<0)
      return 0;
   else if (x == 0.0)
      return 1./Exp(par);
   else {
      Double_t lnpoisson = x*log(par)-par-LnGamma(x+1.);
      return Exp(lnpoisson);
   }
   // An alternative strategy is to transition to a Gaussian approximation for
   // large values of par ...
   //   else {
   //     return Gaus(x,par,Sqrt(par),kTRUE);
   //   }
}

//______________________________________________________________________________
Double_t TMath::PoissonI(Double_t x, Double_t par)
{
  // compute the Poisson distribution function for (x,par)
  // This is a non-smooth function.  
  // This function is equivalent to ROOT::Math::poisson_pdf
//Begin_Html
/*
<img src="gif/PoissonI.gif">
*/
//End_Html

   Int_t ix = Int_t(x);
   return Poisson(ix,par); 
}

//______________________________________________________________________________
Double_t TMath::Prob(Double_t chi2,Int_t ndf)
{
   // Computation of the probability for a certain Chi-squared (chi2)
   // and number of degrees of freedom (ndf).
   //
   // Calculations are based on the incomplete gamma function P(a,x),
   // where a=ndf/2 and x=chi2/2.
   //
   // P(a,x) represents the probability that the observed Chi-squared
   // for a correct model should be less than the value chi2.
   //
   // The returned probability corresponds to 1-P(a,x),
   // which denotes the probability that an observed Chi-squared exceeds
   // the value chi2 by chance, even for a correct model.
   //
   //--- NvE 14-nov-1998 UU-SAP Utrecht

   if (ndf <= 0) return 0; // Set CL to zero in case ndf<=0

   if (chi2 <= 0) {
      if (chi2 < 0) return 0;
      else          return 1;
   }

   return ::ROOT::Math::chisquared_cdf_c(chi2,ndf); 
}

//______________________________________________________________________________
Double_t TMath::KolmogorovProb(Double_t z)
{
   // Calculates the Kolmogorov distribution function,
   //Begin_Html
   /*
   <img src="gif/kolmogorov.gif">
   */
   //End_Html
   // which gives the probability that Kolmogorov's test statistic will exceed
   // the value z assuming the null hypothesis. This gives a very powerful
   // test for comparing two one-dimensional distributions.
   // see, for example, Eadie et al, "statistocal Methods in Experimental
   // Physics', pp 269-270).
   //
   // This function returns the confidence level for the null hypothesis, where:
   //   z = dn*sqrt(n), and
   //   dn  is the maximum deviation between a hypothetical distribution
   //       function and an experimental distribution with
   //   n    events
   //
   // NOTE: To compare two experimental distributions with m and n events,
   //       use z = sqrt(m*n/(m+n))*dn
   //
   // Accuracy: The function is far too accurate for any imaginable application.
   //           Probabilities less than 10^-15 are returned as zero.
   //           However, remember that the formula is only valid for "large" n.
   // Theta function inversion formula is used for z <= 1
   //
   // This function was translated by Rene Brun from PROBKL in CERNLIB.

   Double_t fj[4] = {-2,-8,-18,-32}, r[4];
   const Double_t w = 2.50662827;
   // c1 - -pi**2/8, c2 = 9*c1, c3 = 25*c1
   const Double_t c1 = -1.2337005501361697;
   const Double_t c2 = -11.103304951225528;
   const Double_t c3 = -30.842513753404244;

   Double_t u = TMath::Abs(z);
   Double_t p;
   if (u < 0.2) {
      p = 1;
   } else if (u < 0.755) {
      Double_t v = 1./(u*u);
      p = 1 - w*(TMath::Exp(c1*v) + TMath::Exp(c2*v) + TMath::Exp(c3*v))/u;
   } else if (u < 6.8116) {
      r[1] = 0;
      r[2] = 0;
      r[3] = 0;
      Double_t v = u*u;
      Int_t maxj = TMath::Max(1,TMath::Nint(3./u));
      for (Int_t j=0; j<maxj;j++) {
         r[j] = TMath::Exp(fj[j]*v);
      }
      p = 2*(r[0] - r[1] +r[2] - r[3]);
   } else {
      p = 0;
   }
   return p;
   }

//______________________________________________________________________________
Double_t TMath::KolmogorovTest(Int_t na, const Double_t *a, Int_t nb, const Double_t *b, Option_t *option)
{
//  Statistical test whether two one-dimensional sets of points are compatible
//  with coming from the same parent distribution, using the Kolmogorov test.
//  That is, it is used to compare two experimental distributions of unbinned data.
//
//  Input:
//  a,b: One-dimensional arrays of length na, nb, respectively.
//       The elements of a and b must be given in ascending order.
//  option is a character string to specify options
//         "D" Put out a line of "Debug" printout
//         "M" Return the Maximum Kolmogorov distance instead of prob
//
//  Output:
// The returned value prob is a calculated confidence level which gives a
// statistical test for compatibility of a and b.
// Values of prob close to zero are taken as indicating a small probability
// of compatibility. For two point sets drawn randomly from the same parent
// distribution, the value of prob should be uniformly distributed between
// zero and one.
//   in case of error the function return -1
//   If the 2 sets have a different number of points, the minimum of
//   the two sets is used.
//
// Method:
// The Kolmogorov test is used. The test statistic is the maximum deviation
// between the two integrated distribution functions, multiplied by the
// normalizing factor (rdmax*sqrt(na*nb/(na+nb)).
//
//  Code adapted by Rene Brun from CERNLIB routine TKOLMO (Fred James)
//   (W.T. Eadie, D. Drijard, F.E. James, M. Roos and B. Sadoulet,
//      Statistical Methods in Experimental Physics, (North-Holland,
//      Amsterdam 1971) 269-271)
//
//  Method Improvement by Jason A Detwiler (JADetwiler@lbl.gov)
//  -----------------------------------------------------------
//   The nuts-and-bolts of the TMath::KolmogorovTest() algorithm is a for-loop
//   over the two sorted arrays a and b representing empirical distribution
//   functions. The for-loop handles 3 cases: when the next points to be
//   evaluated satisfy a>b, a<b, or a=b:
//
//      for (Int_t i=0;i<na+nb;i++) {
//         if (a[ia-1] < b[ib-1]) {
//            rdiff -= sa;
//            ia++;
//            if (ia > na) {ok = kTRUE; break;}
//         } else if (a[ia-1] > b[ib-1]) {
//            rdiff += sb;
//            ib++;
//            if (ib > nb) {ok = kTRUE; break;}
//         } else {
//            rdiff += sb - sa;
//            ia++;
//            ib++;
//            if (ia > na) {ok = kTRUE; break;}
//            if (ib > nb) {ok = kTRUE; break;}
//        }
//         rdmax = TMath::Max(rdmax,TMath::Abs(rdiff));
//      }
//
//   For the last case, a=b, the algorithm advances each array by one index in an
//   attempt to move through the equality. However, this is incorrect when one or
//   the other of a or b (or both) have a repeated value, call it x. For the KS
//   statistic to be computed properly, rdiff needs to be calculated after all of
//   the a and b at x have been tallied (this is due to the definition of the
//   empirical distribution function; another way to convince yourself that the
//   old CERNLIB method is wrong is that it implies that the function defined as the
//   difference between a and b is multi-valued at x -- besides being ugly, this
//   would invalidate Kolmogorov's theorem).
//
//   The solution is to just add while-loops into the equality-case handling to
//   perform the tally:
//
//         } else {
//            double x = a[ia-1];
//            while(a[ia-1] == x && ia <= na) {
//              rdiff -= sa;
//              ia++;
//            }
//            while(b[ib-1] == x && ib <= nb) {
//              rdiff += sb;
//              ib++;
//            }
//            if (ia > na) {ok = kTRUE; break;}
//            if (ib > nb) {ok = kTRUE; break;}
//         }
//
//
//  NOTE1
//  A good description of the Kolmogorov test can be seen at:
//    http://www.itl.nist.gov/div898/handbook/eda/section3/eda35g.htm

//  LM: Nov 2010: clean up and returns now a zero distance when vectors are the same 

   TString opt = option;
   opt.ToUpper();

   Double_t prob = -1;
//      Require at least two points in each graph
   if (!a || !b || na <= 2 || nb <= 2) {
      Error("KolmogorovTest","Sets must have more than 2 points");
      return prob;
   }
//     Constants needed
   Double_t rna = na;
   Double_t rnb = nb;
   Double_t sa  = 1./rna;
   Double_t sb  = 1./rnb;
   Double_t rdiff = 0;
   Double_t rdmax = 0;
   Int_t ia = 0;
   Int_t ib = 0;

//    Main loop over point sets to find max distance
//    rdiff is the running difference, and rdmax the max.
   Bool_t ok = kFALSE;
   for (Int_t i=0;i<na+nb;i++) {
      if (a[ia] < b[ib]) {
         rdiff -= sa;
         ia++;
         if (ia >= na) {ok = kTRUE; break;}
      } else if (a[ia] > b[ib]) {
         rdiff += sb;
         ib++;
         if (ib >= nb) {ok = kTRUE; break;}
      } else {
         // special cases for the ties 
         double x = a[ia];
         while(a[ia] == x && ia < na) {
            rdiff -= sa;
            ia++;
         }
         while(b[ib] == x && ib < nb) {
            rdiff += sb;
            ib++;
         }
         if (ia >= na) {ok = kTRUE; break;}
         if (ib >= nb) {ok = kTRUE; break;}
      }
      rdmax = TMath::Max(rdmax,TMath::Abs(rdiff));
   }
   //    Should never terminate this loop with ok = kFALSE!
   R__ASSERT(ok);

   if (ok) {
      rdmax = TMath::Max(rdmax,TMath::Abs(rdiff));
      Double_t z = rdmax * TMath::Sqrt(rna*rnb/(rna+rnb));
      prob = TMath::KolmogorovProb(z);
   }
      // debug printout
   if (opt.Contains("D")) {
      printf(" Kolmogorov Probability = %g, Max Dist = %g\n",prob,rdmax);
   }
   if(opt.Contains("M")) return rdmax;
   else                  return prob;
}


//______________________________________________________________________________
Double_t TMath::Voigt(Double_t xx, Double_t sigma, Double_t lg, Int_t r)
{
   // Computation of Voigt function (normalised).
   // Voigt is a convolution of 
   // gauss(xx) = 1/(sqrt(2*pi)*sigma) * exp(xx*xx/(2*sigma*sigma)
   // and
   // lorentz(xx) = (1/pi) * (lg/2) / (xx*xx + lg*lg/4)
   // functions.
   //
   // The Voigt function is known to be the real part of Faddeeva function also
   // called complex error function [2].
   //
   // The algoritm was developed by J. Humlicek [1].
   // This code is based on fortran code presented by R. J. Wells [2].
   // Translated and adapted by Miha D. Puc
   //
   // To calculate the Faddeeva function with relative error less than 10^(-r).
   // r can be set by the the user subject to the constraints 2 <= r <= 5.
   //
   // [1] J. Humlicek, JQSRT, 21, 437 (1982).
   // [2] R.J. Wells "Rapid Approximation to the Voigt/Faddeeva Function and its
   // Derivatives" JQSRT 62 (1999), pp 29-48.
   // http://www-atm.physics.ox.ac.uk/user/wells/voigt.html

   if ((sigma < 0 || lg < 0) || (sigma==0 && lg==0)) {
      return 0;  // Not meant to be for those who want to be thinner than 0
   }

   if (sigma == 0) {
      return lg * 0.159154943  / (xx*xx + lg*lg /4); //pure Lorentz
   }

   if (lg == 0) {   //pure gauss
      return 0.39894228 / sigma * TMath::Exp(-xx*xx / (2*sigma*sigma));
   }

   Double_t x, y, k;
   x = xx / sigma / 1.41421356;
   y = lg / 2 / sigma / 1.41421356;

   Double_t r0, r1;

   if (r < 2) r = 2;
   if (r > 5) r = 5;

   r0=1.51 * exp(1.144 * (Double_t)r);
   r1=1.60 * exp(0.554 * (Double_t)r);

   // Constants

   const Double_t rrtpi = 0.56418958;  // 1/SQRT(pi)

   Double_t y0, y0py0, y0q;                      // for CPF12 algorithm
   y0 = 1.5;
   y0py0 = y0 + y0;
   y0q = y0 * y0;

   Double_t c[6] = { 1.0117281, -0.75197147, 0.012557727, 0.010022008, -0.00024206814, 0.00000050084806};
   Double_t s[6] = { 1.393237, 0.23115241, -0.15535147, 0.0062183662, 0.000091908299, -0.00000062752596};
   Double_t t[6] = { 0.31424038, 0.94778839, 1.5976826, 2.2795071, 3.0206370, 3.8897249};

   // Local variables

   int j;                                        // Loop variables
   int rg1, rg2, rg3;                            // y polynomial flags
   Double_t abx, xq, yq, yrrtpi;                 // --x--, x^2, y^2, y/SQRT(pi)
   Double_t xlim0, xlim1, xlim2, xlim3, xlim4;   // --x-- on region boundaries
   Double_t a0=0, d0=0, d2=0, e0=0, e2=0, e4=0, h0=0, h2=0, h4=0, h6=0;// W4 temporary variables
   Double_t p0=0, p2=0, p4=0, p6=0, p8=0, z0=0, z2=0, z4=0, z6=0, z8=0;
   Double_t xp[6], xm[6], yp[6], ym[6];          // CPF12 temporary values
   Double_t mq[6], pq[6], mf[6], pf[6];
   Double_t d, yf, ypy0, ypy0q;

   //***** Start of executable code *****************************************

   rg1 = 1;  // Set flags
   rg2 = 1;
   rg3 = 1;
   yq = y * y;  // y^2
   yrrtpi = y * rrtpi;  // y/SQRT(pi)

   // Region boundaries when both k and L are required or when R<>4

   xlim0 = r0 - y;
   xlim1 = r1 - y;
   xlim3 = 3.097 * y - 0.45;
   xlim2 = 6.8 - y;
   xlim4 = 18.1 * y + 1.65;
   if ( y <= 1e-6 ) {                      // When y<10^-6 avoid W4 algorithm
      xlim1 = xlim0;
      xlim2 = xlim0;
   }

   abx = fabs(x);                                // |x|
   xq = abx * abx;                               // x^2
   if ( abx > xlim0 ) {                          // Region 0 algorithm
      k = yrrtpi / (xq + yq);
   } else if ( abx > xlim1 ) {                   // Humlicek W4 Region 1
      if ( rg1 != 0 ) {                          // First point in Region 1
         rg1 = 0;
         a0 = yq + 0.5;                          // Region 1 y-dependents
         d0 = a0*a0;
         d2 = yq + yq - 1.0;
      }
      d = rrtpi / (d0 + xq*(d2 + xq));
      k = d * y * (a0 + xq);
   } else if ( abx > xlim2 ) {                   // Humlicek W4 Region 2
      if ( rg2 != 0 ) {                          // First point in Region 2
         rg2 = 0;
         h0 = 0.5625 + yq * (4.5 + yq * (10.5 + yq * (6.0 + yq)));
                                                 // Region 2 y-dependents
         h2 = -4.5 + yq * (9.0 + yq * ( 6.0 + yq * 4.0));
         h4 = 10.5 - yq * (6.0 - yq * 6.0);
         h6 = -6.0 + yq * 4.0;
         e0 = 1.875 + yq * (8.25 + yq * (5.5 + yq));
         e2 = 5.25 + yq * (1.0 + yq * 3.0);
         e4 = 0.75 * h6;
      }
      d = rrtpi / (h0 + xq * (h2 + xq * (h4 + xq * (h6 + xq))));
      k = d * y * (e0 + xq * (e2 + xq * (e4 + xq)));
   } else if ( abx < xlim3 ) {                   // Humlicek W4 Region 3
      if ( rg3 != 0 ) {                          // First point in Region 3
         rg3 = 0;
         z0 = 272.1014 + y * (1280.829 + y *
                              (2802.870 + y *
                               (3764.966 + y *
                                (3447.629 + y *
                                 (2256.981 + y *
                                  (1074.409 + y *
                                   (369.1989  + y *
                                    (88.26741 + y *
                                     (13.39880 + y)
                                     ))))))));   // Region 3 y-dependents
         z2 = 211.678 + y * (902.3066 + y *
                             (1758.336 + y *
                              (2037.310 + y *
                               (1549.675 + y *
                                (793.4273 + y *
                                 (266.2987 + y *
                                  (53.59518 + y * 5.0)
                                  ))))));
         z4 = 78.86585 + y * (308.1852 + y *
                              (497.3014 + y *
                               (479.2576 + y *
                                (269.2916 + y *
                                 (80.39278 + y * 10.0)
                                 ))));
         z6 = 22.03523 + y * (55.02933 + y *
                              (92.75679 + y *
                               (53.59518 + y * 10.0)
                               ));
         z8 = 1.496460 + y * (13.39880 + y * 5.0);
         p0 = 153.5168 + y * (549.3954 + y *
                              (919.4955 + y *
                               (946.8970 + y *
                                (662.8097 + y *
                                 (328.2151 + y *
                                  (115.3772 + y *
                                   (27.93941 + y *
                                    (4.264678 + y * 0.3183291)
                                    )))))));
         p2 = -34.16955 + y * (-1.322256+ y *
                               (124.5975 + y *
                                (189.7730 + y *
                                 (139.4665 + y *
                                  (56.81652 + y *
                                   (12.79458 + y * 1.2733163)
                                   )))));
         p4 = 2.584042 + y * (10.46332 + y *
                              (24.01655 + y *
                               (29.81482 + y *
                                (12.79568 + y * 1.9099744)
                                )));
         p6 = -0.07272979 + y * (0.9377051 + y *
                                 (4.266322 + y * 1.273316));
         p8 = 0.0005480304 + y * 0.3183291;
      }
      d = 1.7724538 / (z0 + xq * (z2 + xq * (z4 + xq * (z6 + xq * (z8 + xq)))));
      k = d * (p0 + xq * (p2 + xq * (p4 + xq * (p6 + xq * p8))));
   } else {                             // Humlicek CPF12 algorithm
      ypy0 = y + y0;
      ypy0q = ypy0 * ypy0;
      k = 0.0;
      for (j = 0; j <= 5; j++) {
         d = x - t[j];
         mq[j] = d * d;
         mf[j] = 1.0 / (mq[j] + ypy0q);
         xm[j] = mf[j] * d;
         ym[j] = mf[j] * ypy0;
         d = x + t[j];
         pq[j] = d * d;
         pf[j] = 1.0 / (pq[j] + ypy0q);
         xp[j] = pf[j] * d;
         yp[j] = pf[j] * ypy0;
      }
      if ( abx <= xlim4 ) {                      // Humlicek CPF12 Region I
         for (j = 0; j <= 5; j++) {
            k = k + c[j]*(ym[j]+yp[j]) - s[j]*(xm[j]-xp[j]) ;
         }
      } else {                                   // Humlicek CPF12 Region II
         yf = y + y0py0;
         for ( j = 0; j <= 5; j++) {
            k = k + (c[j] *
                 (mq[j] * mf[j] - y0 * ym[j])
                    + s[j] * yf * xm[j]) / (mq[j]+y0q)
                 + (c[j] * (pq[j] * pf[j] - y0 * yp[j])
                   - s[j] * yf * xp[j]) / (pq[j]+y0q);
         }
         k = y * k + exp( -xq );
      }
   }
   return k / 2.506628 / sigma; // Normalize by dividing by sqrt(2*pi)*sigma.
}

//______________________________________________________________________________
Bool_t TMath::RootsCubic(const Double_t coef[4],Double_t &a, Double_t &b, Double_t &c)
{
   // Calculates roots of polynomial of 3rd order a*x^3 + b*x^2 + c*x + d, where
   // a == coef[3], b == coef[2], c == coef[1], d == coef[0]
   //coef[3] must be different from 0
   // If the boolean returned by the method is false:
   //    ==> there are 3 real roots a,b,c
   // If the boolean returned by the method is true:
   //    ==> there is one real root a and 2 complex conjugates roots (b+i*c,b-i*c)
   // Author: Francois-Xavier Gentit

   Bool_t complex = kFALSE;
   Double_t r,s,t,p,q,d,ps3,ps33,qs2,u,v,tmp,lnu,lnv,su,sv,y1,y2,y3;
   a    = 0;
   b    = 0;
   c    = 0;
   if (coef[3] == 0) return complex;
   r    = coef[2]/coef[3];
   s    = coef[1]/coef[3];
   t    = coef[0]/coef[3];
   p    = s - (r*r)/3;
   ps3  = p/3;
   q    = (2*r*r*r)/27.0 - (r*s)/3 + t;
   qs2  = q/2;
   ps33 = ps3*ps3*ps3;
   d    = ps33 + qs2*qs2;
   if (d>=0) {
      complex = kTRUE;
      d   = TMath::Sqrt(d);
      u   = -qs2 + d;
      v   = -qs2 - d;
      tmp = 1./3.;
      lnu = TMath::Log(TMath::Abs(u));
      lnv = TMath::Log(TMath::Abs(v));
      su  = TMath::Sign(1.,u);
      sv  = TMath::Sign(1.,v);
      u   = su*TMath::Exp(tmp*lnu);
      v   = sv*TMath::Exp(tmp*lnv);
      y1  = u + v;
      y2  = -y1/2;
      y3  = ((u-v)*TMath::Sqrt(3.))/2;
      tmp = r/3;
      a   = y1 - tmp;
      b   = y2 - tmp;
      c   = y3;
   } else {
      Double_t phi,cphi,phis3,c1,c2,c3,pis3;
      ps3   = -ps3;
      ps33  = -ps33;
      cphi  = -qs2/TMath::Sqrt(ps33);
      phi   = TMath::ACos(cphi);
      phis3 = phi/3;
      pis3  = TMath::Pi()/3;
      c1    = TMath::Cos(phis3);
      c2    = TMath::Cos(pis3 + phis3);
      c3    = TMath::Cos(pis3 - phis3);
      tmp   = TMath::Sqrt(ps3);
      y1    = 2*tmp*c1;
      y2    = -2*tmp*c2;
      y3    = -2*tmp*c3;
      tmp = r/3;
      a   = y1 - tmp;
      b   = y2 - tmp;
      c   = y3 - tmp;
   }
   return complex;
}

//______________________________________________________________________________
void TMath::Quantiles(Int_t n, Int_t nprob, Double_t *x, Double_t *quantiles, Double_t *prob, Bool_t isSorted, Int_t *index, Int_t type)
{
   //Computes sample quantiles, corresponding to the given probabilities
   //Parameters:
   //  x -the data sample
   //  n - its size
   //  quantiles - computed quantiles are returned in there
   //  prob - probabilities where to compute quantiles
   //  nprob - size of prob array
   //  isSorted - is the input array x sorted?
   //  NOTE, that when the input is not sorted, an array of integers of size n needs
   //        to be allocated. It can be passed by the user in parameter index,
   //        or, if not passed, it will be allocated inside the function
   //
   //  type - method to compute (from 1 to 9). Following types are provided:
   //  Discontinuous:
   //    type=1 - inverse of the empirical distribution function
   //    type=2 - like type 1, but with averaging at discontinuities
   //    type=3 - SAS definition: nearest even order statistic
   //  Piecwise linear continuous:
   //    In this case, sample quantiles can be obtained by linear interpolation
   //    between the k-th order statistic and p(k).
   //    type=4 - linear interpolation of empirical cdf, p(k)=k/n;
   //    type=5 - a very popular definition, p(k) = (k-0.5)/n;
   //    type=6 - used by Minitab and SPSS, p(k) = k/(n+1);
   //    type=7 - used by S-Plus and R, p(k) = (k-1)/(n-1);
   //    type=8 - resulting sample quantiles are approximately median unbiased
   //             regardless of the distribution of x. p(k) = (k-1/3)/(n+1/3);
   //    type=9 - resulting sample quantiles are approximately unbiased, when
   //             the sample comes from Normal distribution. p(k)=(k-3/8)/(n+1/4);
   //
   //    default type = 7
   //
   // References:
   // 1) Hyndman, R.J and Fan, Y, (1996) "Sample quantiles in statistical packages"
   //                                     American Statistician, 50, 361-365
   // 2) R Project documentation for the function quantile of package {stats}

   if (type<1 || type>9){
      printf("illegal value of type\n");
      return;
   }
   Double_t g, npm, np, xj, xjj;
   Int_t j, intnpm;
   Int_t *ind = 0;
   Bool_t isAllocated = kFALSE;
   if (!isSorted){
      if (index) ind = index;
      else {
         ind = new Int_t[n];
         isAllocated = kTRUE;
      }
   }
   npm=0;
   //Discontinuous functions
   if (type<4){
      for (Int_t i=0; i<nprob; i++){
         npm = n*prob[i];
         if (npm < 1){
            if(isSorted)
               quantiles[i] = x[0];
            else
               quantiles[i] = TMath::KOrdStat(n, x, 0, ind);
         } else {
            j=TMath::Max(TMath::FloorNint(npm)-1, 0);
            if (npm - j -1 > 1e-14){
               if (isSorted)
                  quantiles[i] = x[j+1];
               else
                  quantiles[i] = TMath::KOrdStat(n, x, j+1, ind);
            } else {
               if (isSorted) xj = x[j];
               else xj = TMath::KOrdStat(n, x, j, ind);
               if (type==1) quantiles[i] = xj;
               if (type==2) {
                  if (isSorted) xjj = x[j+1];
                  else xjj = TMath::KOrdStat(n, x, j+1, ind);
                  quantiles[i] = 0.5*(xj + xjj);
               }
               if (type==3) {
                  if (!TMath::Even(j-1)){
                     if (isSorted) xjj = x[j+1];
                     else xjj = TMath::KOrdStat(n, x, j+1, ind);
                     quantiles[i] = xjj;
                  } else
                     quantiles[i] = xj;
               }
            }
         }
      }
   }
   if (type>3){
      for (Int_t i=0; i<nprob; i++){
         np=n*prob[i];
         if (np<1 && type!=7 && type!=4)
            quantiles[i] = TMath::KOrdStat(n, x, 0, ind);
         else {
            if (type==4) npm = np;
            if (type==5) npm = np + 0.5;
            if (type==6) npm = np + prob[i];
            if (type==7) npm = np - prob[i] +1;
            if (type==8) npm = np+(1./3.)*(1+prob[i]);
            if (type==9) npm = np + 0.25*prob[i] + 0.375;
            intnpm = TMath::FloorNint(npm);
            j = TMath::Max(intnpm - 1, 0);
            g = npm - intnpm;
            if (isSorted){
               xj = x[j];
               xjj = x[j+1];
            } else {
               xj = TMath::KOrdStat(n, x, j, ind);
               xjj = TMath::KOrdStat(n, x, j+1, ind);
            }
            quantiles[i] = (1-g)*xj + g*xjj;
         }
      }
   }

   if (isAllocated)
      delete [] ind;
}

//______________________________________________________________________________
void TMath::BubbleHigh(Int_t Narr, Double_t *arr1, Int_t *arr2)
{
   // Bubble sort variant to obtain the order of an array's elements into
   // an index in order to do more useful things than the standard built
   // in functions.
   // *arr1 is unchanged;
   // *arr2 is the array of indicies corresponding to the decending value
   // of arr1 with arr2[0] corresponding to the largest arr1 value and
   // arr2[Narr] the smallest.
   //
   //  Author: Adrian Bevan (bevan@slac.stanford.edu)

   if (Narr <= 0) return;
   double *localArr1 = new double[Narr];
   int    *localArr2 = new int[Narr];
   int iEl;
   int iEl2;

   for(iEl = 0; iEl < Narr; iEl++) {
      localArr1[iEl] = arr1[iEl];
      localArr2[iEl] = iEl;
   }

   for (iEl = 0; iEl < Narr; iEl++) {
      for (iEl2 = Narr-1; iEl2 > iEl; --iEl2) {
         if (localArr1[iEl2-1] < localArr1[iEl2]) {
            double tmp        = localArr1[iEl2-1];
            localArr1[iEl2-1] = localArr1[iEl2];
            localArr1[iEl2]   = tmp;

            int    tmp2       = localArr2[iEl2-1];
            localArr2[iEl2-1] = localArr2[iEl2];
            localArr2[iEl2]   = tmp2;
         }
      }
   }

   for (iEl = 0; iEl < Narr; iEl++) {
      arr2[iEl] = localArr2[iEl];
   }
   delete [] localArr2;
   delete [] localArr1;
}

//______________________________________________________________________________
void TMath::BubbleLow(Int_t Narr, Double_t *arr1, Int_t *arr2)
{
   // Opposite ordering of the array arr2[] to that of BubbleHigh.
   //
   //  Author: Adrian Bevan (bevan@slac.stanford.edu)

   if (Narr <= 0) return;
   double *localArr1 = new double[Narr];
   int    *localArr2 = new int[Narr];
   int iEl;
   int iEl2;

   for (iEl = 0; iEl < Narr; iEl++) {
      localArr1[iEl] = arr1[iEl];
      localArr2[iEl] = iEl;
   }

   for (iEl = 0; iEl < Narr; iEl++) {
      for (iEl2 = Narr-1; iEl2 > iEl; --iEl2) {
         if (localArr1[iEl2-1] > localArr1[iEl2]) {
            double tmp        = localArr1[iEl2-1];
            localArr1[iEl2-1] = localArr1[iEl2];
            localArr1[iEl2]   = tmp;

            int    tmp2       = localArr2[iEl2-1];
            localArr2[iEl2-1] = localArr2[iEl2];
            localArr2[iEl2]   = tmp2;
         }
      }
   }

   for (iEl = 0; iEl < Narr; iEl++) {
      arr2[iEl] = localArr2[iEl];
   }
   delete [] localArr2;
   delete [] localArr1;
}


//______________________________________________________________________________
ULong_t TMath::Hash(const void *txt, Int_t ntxt)
{
   // Calculates hash index from any char string.
   // Based on precalculated table of 256 specially selected numbers.
   // These numbers are selected in such a way, that for string
   // length == 4 (integer number) the hash is unambigous, i.e.
   // from hash value we can recalculate input (no degeneration).
   //
   // The quality of hash method is good enough, that
   // "random" numbers made as R = Hash(1), Hash(2), ...Hash(N)
   // tested by <R>, <R*R>, <Ri*Ri+1> gives the same result
   // as for libc rand().
   //
   // For string:  i = TMath::Hash(string,nstring);
   // For int:     i = TMath::Hash(&intword,sizeof(int));
   // For pointer: i = TMath::Hash(&pointer,sizeof(void*));
   //
   //              V.Perev
   // This function is kept for back compatibility. The code previously in this function
   // has been moved to the static function TString::Hash

   return TString::Hash(txt,ntxt);
}


//______________________________________________________________________________
ULong_t TMath::Hash(const char *txt)
{
   return Hash(txt, Int_t(strlen(txt)));
}

//______________________________________________________________________________
Double_t TMath::BesselI0(Double_t x)
{
   // Compute the modified Bessel function I_0(x) for any real x.
   //
   //--- NvE 12-mar-2000 UU-SAP Utrecht

   // Parameters of the polynomial approximation
   const Double_t p1=1.0,          p2=3.5156229,    p3=3.0899424,
                  p4=1.2067492,    p5=0.2659732,    p6=3.60768e-2,  p7=4.5813e-3;

   const Double_t q1= 0.39894228,  q2= 1.328592e-2, q3= 2.25319e-3,
                  q4=-1.57565e-3,  q5= 9.16281e-3,  q6=-2.057706e-2,
                  q7= 2.635537e-2, q8=-1.647633e-2, q9= 3.92377e-3;

   const Double_t k1 = 3.75;
   Double_t ax = TMath::Abs(x);

   Double_t y=0, result=0;

   if (ax < k1) {
      Double_t xx = x/k1;
      y = xx*xx;
      result = p1+y*(p2+y*(p3+y*(p4+y*(p5+y*(p6+y*p7)))));
   } else {
      y = k1/ax;
      result = (TMath::Exp(ax)/TMath::Sqrt(ax))*(q1+y*(q2+y*(q3+y*(q4+y*(q5+y*(q6+y*(q7+y*(q8+y*q9))))))));
   }
   return result;
}

//______________________________________________________________________________
Double_t TMath::BesselK0(Double_t x)
{
   // Compute the modified Bessel function K_0(x) for positive real x.
   //
   //  M.Abramowitz and I.A.Stegun, Handbook of Mathematical Functions,
   //     Applied Mathematics Series vol. 55 (1964), Washington.
   //
   //--- NvE 12-mar-2000 UU-SAP Utrecht

   // Parameters of the polynomial approximation
   const Double_t p1=-0.57721566,  p2=0.42278420,   p3=0.23069756,
                  p4= 3.488590e-2, p5=2.62698e-3,   p6=1.0750e-4,    p7=7.4e-6;

   const Double_t q1= 1.25331414,  q2=-7.832358e-2, q3= 2.189568e-2,
                  q4=-1.062446e-2, q5= 5.87872e-3,  q6=-2.51540e-3,  q7=5.3208e-4;

   if (x <= 0) {
      Error("TMath::BesselK0", "*K0* Invalid argument x = %g\n",x);
      return 0;
   }

   Double_t y=0, result=0;

   if (x <= 2) {
      y = x*x/4;
      result = (-log(x/2.)*TMath::BesselI0(x))+(p1+y*(p2+y*(p3+y*(p4+y*(p5+y*(p6+y*p7))))));
   } else {
      y = 2/x;
      result = (exp(-x)/sqrt(x))*(q1+y*(q2+y*(q3+y*(q4+y*(q5+y*(q6+y*q7))))));
   }
   return result;
}

//______________________________________________________________________________
Double_t TMath::BesselI1(Double_t x)
{
   // Compute the modified Bessel function I_1(x) for any real x.
   //
   //  M.Abramowitz and I.A.Stegun, Handbook of Mathematical Functions,
   //     Applied Mathematics Series vol. 55 (1964), Washington.
   //
   //--- NvE 12-mar-2000 UU-SAP Utrecht

   // Parameters of the polynomial approximation
   const Double_t p1=0.5,          p2=0.87890594,   p3=0.51498869,
                  p4=0.15084934,   p5=2.658733e-2,  p6=3.01532e-3,  p7=3.2411e-4;

   const Double_t q1= 0.39894228,  q2=-3.988024e-2, q3=-3.62018e-3,
                  q4= 1.63801e-3,  q5=-1.031555e-2, q6= 2.282967e-2,
                  q7=-2.895312e-2, q8= 1.787654e-2, q9=-4.20059e-3;

   const Double_t k1 = 3.75;
   Double_t ax = TMath::Abs(x);

   Double_t y=0, result=0;

   if (ax < k1) {
      Double_t xx = x/k1;
      y = xx*xx;
      result = x*(p1+y*(p2+y*(p3+y*(p4+y*(p5+y*(p6+y*p7))))));
   } else {
      y = k1/ax;
      result = (exp(ax)/sqrt(ax))*(q1+y*(q2+y*(q3+y*(q4+y*(q5+y*(q6+y*(q7+y*(q8+y*q9))))))));
      if (x < 0) result = -result;
   }
   return result;
}

//______________________________________________________________________________
Double_t TMath::BesselK1(Double_t x)
{
   // Compute the modified Bessel function K_1(x) for positive real x.
   //
   //  M.Abramowitz and I.A.Stegun, Handbook of Mathematical Functions,
   //     Applied Mathematics Series vol. 55 (1964), Washington.
   //
   //--- NvE 12-mar-2000 UU-SAP Utrecht

   // Parameters of the polynomial approximation
   const Double_t p1= 1.,          p2= 0.15443144,  p3=-0.67278579,
                  p4=-0.18156897,  p5=-1.919402e-2, p6=-1.10404e-3,  p7=-4.686e-5;

   const Double_t q1= 1.25331414,  q2= 0.23498619,  q3=-3.655620e-2,
                  q4= 1.504268e-2, q5=-7.80353e-3,  q6= 3.25614e-3,  q7=-6.8245e-4;

   if (x <= 0) {
      Error("TMath::BesselK1", "*K1* Invalid argument x = %g\n",x);
      return 0;
   }

   Double_t y=0,result=0;

   if (x <= 2) {
      y = x*x/4;
      result = (log(x/2.)*TMath::BesselI1(x))+(1./x)*(p1+y*(p2+y*(p3+y*(p4+y*(p5+y*(p6+y*p7))))));
   } else {
      y = 2/x;
      result = (exp(-x)/sqrt(x))*(q1+y*(q2+y*(q3+y*(q4+y*(q5+y*(q6+y*q7))))));
   }
   return result;
}

//______________________________________________________________________________
Double_t TMath::BesselK(Int_t n,Double_t x)
{
   // Compute the Integer Order Modified Bessel function K_n(x)
   // for n=0,1,2,... and positive real x.
   //
   //--- NvE 12-mar-2000 UU-SAP Utrecht

   if (x <= 0 || n < 0) {
      Error("TMath::BesselK", "*K* Invalid argument(s) (n,x) = (%d, %g)\n",n,x);
      return 0;
   }

   if (n==0) return TMath::BesselK0(x);
   if (n==1) return TMath::BesselK1(x);

   // Perform upward recurrence for all x
   Double_t tox = 2/x;
   Double_t bkm = TMath::BesselK0(x);
   Double_t bk  = TMath::BesselK1(x);
   Double_t bkp = 0;
   for (Int_t j=1; j<n; j++) {
      bkp = bkm+Double_t(j)*tox*bk;
      bkm = bk;
      bk  = bkp;
   }
   return bk;
}

//______________________________________________________________________________
Double_t TMath::BesselI(Int_t n,Double_t x)
{
   // Compute the Integer Order Modified Bessel function I_n(x)
   // for n=0,1,2,... and any real x.
   //
   //--- NvE 12-mar-2000 UU-SAP Utrecht

   Int_t iacc = 40; // Increase to enhance accuracy
   const Double_t kBigPositive = 1.e10;
   const Double_t kBigNegative = 1.e-10;

   if (n < 0) {
      Error("TMath::BesselI", "*I* Invalid argument (n,x) = (%d, %g)\n",n,x);
      return 0;
   }

   if (n==0) return TMath::BesselI0(x);
   if (n==1) return TMath::BesselI1(x);

   if (x == 0) return 0;
   if (TMath::Abs(x) > kBigPositive) return 0;

   Double_t tox = 2/TMath::Abs(x);
   Double_t bip = 0, bim = 0;
   Double_t bi  = 1;
   Double_t result = 0;
   Int_t m = 2*((n+Int_t(sqrt(Float_t(iacc*n)))));
   for (Int_t j=m; j>=1; j--) {
      bim = bip+Double_t(j)*tox*bi;
      bip = bi;
      bi  = bim;
      // Renormalise to prevent overflows
      if (TMath::Abs(bi) > kBigPositive)  {
         result *= kBigNegative;
         bi     *= kBigNegative;
         bip    *= kBigNegative;
      }
      if (j==n) result=bip;
   }

   result *= TMath::BesselI0(x)/bi; // Normalise with BesselI0(x)
   if ((x < 0) && (n%2 == 1)) result = -result;

   return result;
}

//______________________________________________________________________________
Double_t TMath::BesselJ0(Double_t x)
{
   // Returns the Bessel function J0(x) for any real x.

   Double_t ax,z;
   Double_t xx,y,result,result1,result2;
   const Double_t p1  = 57568490574.0, p2  = -13362590354.0, p3 = 651619640.7;
   const Double_t p4  = -11214424.18,  p5  = 77392.33017,    p6 = -184.9052456;
   const Double_t p7  = 57568490411.0, p8  = 1029532985.0,   p9 = 9494680.718;
   const Double_t p10 = 59272.64853,   p11 = 267.8532712;

   const Double_t q1  = 0.785398164;
   const Double_t q2  = -0.1098628627e-2,  q3  = 0.2734510407e-4;
   const Double_t q4  = -0.2073370639e-5,  q5  = 0.2093887211e-6;
   const Double_t q6  = -0.1562499995e-1,  q7  = 0.1430488765e-3;
   const Double_t q8  = -0.6911147651e-5,  q9  = 0.7621095161e-6;
   const Double_t q10 =  0.934935152e-7,   q11 = 0.636619772;

   if ((ax=fabs(x)) < 8) {
      y=x*x;
      result1 = p1 + y*(p2 + y*(p3 + y*(p4  + y*(p5  + y*p6))));
      result2 = p7 + y*(p8 + y*(p9 + y*(p10 + y*(p11 + y))));
      result  = result1/result2;
   } else {
      z  = 8/ax;
      y  = z*z;
      xx = ax-q1;
      result1 = 1  + y*(q2 + y*(q3 + y*(q4 + y*q5)));
      result2 = q6 + y*(q7 + y*(q8 + y*(q9 - y*q10)));
      result  = sqrt(q11/ax)*(cos(xx)*result1-z*sin(xx)*result2);
   }
   return result;
}

//______________________________________________________________________________
Double_t TMath::BesselJ1(Double_t x)
{
   // Returns the Bessel function J1(x) for any real x.

   Double_t ax,z;
   Double_t xx,y,result,result1,result2;
   const Double_t p1  = 72362614232.0,  p2  = -7895059235.0, p3 = 242396853.1;
   const Double_t p4  = -2972611.439,   p5  = 15704.48260,   p6 = -30.16036606;
   const Double_t p7  = 144725228442.0, p8  = 2300535178.0,  p9 = 18583304.74;
   const Double_t p10 = 99447.43394,    p11 = 376.9991397;

   const Double_t q1  = 2.356194491;
   const Double_t q2  = 0.183105e-2,     q3  = -0.3516396496e-4;
   const Double_t q4  = 0.2457520174e-5, q5  = -0.240337019e-6;
   const Double_t q6  = 0.04687499995,   q7  = -0.2002690873e-3;
   const Double_t q8  = 0.8449199096e-5, q9  = -0.88228987e-6;
   const Double_t q10 = 0.105787412e-6,  q11 = 0.636619772;

   if ((ax=fabs(x)) < 8) {
      y=x*x;
      result1 = x*(p1 + y*(p2 + y*(p3 + y*(p4  + y*(p5  + y*p6)))));
      result2 = p7    + y*(p8 + y*(p9 + y*(p10 + y*(p11 + y))));
      result  = result1/result2;
   } else {
      z  = 8/ax;
      y  = z*z;
      xx = ax-q1;
      result1 = 1  + y*(q2 + y*(q3 + y*(q4 + y*q5)));
      result2 = q6 + y*(q7 + y*(q8 + y*(q9 + y*q10)));
      result  = sqrt(q11/ax)*(cos(xx)*result1-z*sin(xx)*result2);
      if (x < 0) result = -result;
   }
   return result;
}

//______________________________________________________________________________
Double_t TMath::BesselY0(Double_t x)
{
   // Returns the Bessel function Y0(x) for positive x.

   Double_t z,xx,y,result,result1,result2;
   const Double_t p1  = -2957821389.,  p2  = 7062834065.0, p3  = -512359803.6;
   const Double_t p4  = 10879881.29,   p5  = -86327.92757, p6  = 228.4622733;
   const Double_t p7  = 40076544269.,  p8  = 745249964.8,  p9  = 7189466.438;
   const Double_t p10 = 47447.26470,   p11 = 226.1030244,  p12 = 0.636619772;

   const Double_t q1  =  0.785398164;
   const Double_t q2  = -0.1098628627e-2, q3  = 0.2734510407e-4;
   const Double_t q4  = -0.2073370639e-5, q5  = 0.2093887211e-6;
   const Double_t q6  = -0.1562499995e-1, q7  = 0.1430488765e-3;
   const Double_t q8  = -0.6911147651e-5, q9  = 0.7621095161e-6;
   const Double_t q10 = -0.934945152e-7,  q11 = 0.636619772;

   if (x < 8) {
      y = x*x;
      result1 = p1 + y*(p2 + y*(p3 + y*(p4  + y*(p5  + y*p6))));
      result2 = p7 + y*(p8 + y*(p9 + y*(p10 + y*(p11 + y))));
      result  = (result1/result2) + p12*TMath::BesselJ0(x)*log(x);
   } else {
      z  = 8/x;
      y  = z*z;
      xx = x-q1;
      result1 = 1  + y*(q2 + y*(q3 + y*(q4 + y*q5)));
      result2 = q6 + y*(q7 + y*(q8 + y*(q9 + y*q10)));
      result  = sqrt(q11/x)*(sin(xx)*result1+z*cos(xx)*result2);
   }
   return result;
}

//______________________________________________________________________________
Double_t TMath::BesselY1(Double_t x)
{
   // Returns the Bessel function Y1(x) for positive x.

   Double_t z,xx,y,result,result1,result2;
   const Double_t p1  = -0.4900604943e13, p2  = 0.1275274390e13;
   const Double_t p3  = -0.5153438139e11, p4  = 0.7349264551e9;
   const Double_t p5  = -0.4237922726e7,  p6  = 0.8511937935e4;
   const Double_t p7  =  0.2499580570e14, p8  = 0.4244419664e12;
   const Double_t p9  =  0.3733650367e10, p10 = 0.2245904002e8;
   const Double_t p11 =  0.1020426050e6,  p12 = 0.3549632885e3;
   const Double_t p13 =  0.636619772;
   const Double_t q1  =  2.356194491;
   const Double_t q2  =  0.183105e-2,     q3  = -0.3516396496e-4;
   const Double_t q4  =  0.2457520174e-5, q5  = -0.240337019e-6;
   const Double_t q6  =  0.04687499995,   q7  = -0.2002690873e-3;
   const Double_t q8  =  0.8449199096e-5, q9  = -0.88228987e-6;
   const Double_t q10 =  0.105787412e-6,  q11 =  0.636619772;

   if (x < 8) {
      y=x*x;
      result1 = x*(p1 + y*(p2 + y*(p3 + y*(p4 + y*(p5  + y*p6)))));
      result2 = p7 + y*(p8 + y*(p9 + y*(p10 + y*(p11  + y*(p12+y)))));
      result  = (result1/result2) + p13*(TMath::BesselJ1(x)*log(x)-1/x);
   } else {
      z  = 8/x;
      y  = z*z;
      xx = x-q1;
      result1 = 1  + y*(q2 + y*(q3 + y*(q4 + y*q5)));
      result2 = q6 + y*(q7 + y*(q8 + y*(q9 + y*q10)));
      result  = sqrt(q11/x)*(sin(xx)*result1+z*cos(xx)*result2);
   }
   return result;
}

//______________________________________________________________________________
Double_t TMath::StruveH0(Double_t x)
{
   // Struve Functions of Order 0
   //
   // Converted from CERNLIB M342 by Rene Brun.

   const Int_t n1 = 15;
   const Int_t n2 = 25;
   const Double_t c1[16] = { 1.00215845609911981, -1.63969292681309147,
                             1.50236939618292819, -.72485115302121872,
                              .18955327371093136, -.03067052022988,
                              .00337561447375194, -2.6965014312602e-4,
                             1.637461692612e-5,   -7.8244408508e-7,
                             3.021593188e-8,      -9.6326645e-10,
                             2.579337e-11,        -5.8854e-13,
                             1.158e-14,           -2e-16 };
   const Double_t c2[26] = {  .99283727576423943, -.00696891281138625,
                             1.8205103787037e-4,  -1.063258252844e-5,
                             9.8198294287e-7,     -1.2250645445e-7,
                             1.894083312e-8,      -3.44358226e-9,
                             7.1119102e-10,       -1.6288744e-10,
                             4.065681e-11,        -1.091505e-11,
                             3.12005e-12,         -9.4202e-13,
                             2.9848e-13,          -9.872e-14,
                             3.394e-14,           -1.208e-14,
                             4.44e-15,            -1.68e-15,
                             6.5e-16,             -2.6e-16,
                             1.1e-16,             -4e-17,
                             2e-17,               -1e-17 };

   const Double_t c0  = 2/TMath::Pi();

   Int_t i;
   Double_t alfa, h, r, y, b0, b1, b2;
   Double_t v = TMath::Abs(x);

   v = TMath::Abs(x);
   if (v < 8) {
      y = v/8;
      h = 2*y*y -1;
      alfa = h + h;
      b0 = 0;
      b1 = 0;
      b2 = 0;
      for (i = n1; i >= 0; --i) {
         b0 = c1[i] + alfa*b1 - b2;
         b2 = b1;
         b1 = b0;
      }
      h = y*(b0 - h*b2);
   } else {
      r = 1/v;
      h = 128*r*r -1;
      alfa = h + h;
      b0 = 0;
      b1 = 0;
      b2 = 0;
      for (i = n2; i >= 0; --i) {
         b0 = c2[i] + alfa*b1 - b2;
         b2 = b1;
         b1 = b0;
      }
      h = TMath::BesselY0(v) + r*c0*(b0 - h*b2);
   }
   if (x < 0)  h = -h;
   return h;
}

//______________________________________________________________________________
Double_t TMath::StruveH1(Double_t x)
{
   // Struve Functions of Order 1
   //
   // Converted from CERNLIB M342 by Rene Brun.

   const Int_t n3 = 16;
   const Int_t n4 = 22;
   const Double_t c3[17] = { .5578891446481605,   -.11188325726569816,
                            -.16337958125200939,   .32256932072405902,
                            -.14581632367244242,   .03292677399374035,
                            -.00460372142093573,  4.434706163314e-4,
                            -3.142099529341e-5,   1.7123719938e-6,
                            -7.416987005e-8,      2.61837671e-9,
                            -7.685839e-11,        1.9067e-12,
                            -4.052e-14,           7.5e-16,
                            -1e-17 };
   const Double_t c4[23] = { 1.00757647293865641,  .00750316051248257,
                            -7.043933264519e-5,   2.66205393382e-6,
                            -1.8841157753e-7,     1.949014958e-8,
                            -2.6126199e-9,        4.236269e-10,
                            -7.955156e-11,        1.679973e-11,
                            -3.9072e-12,          9.8543e-13,
                            -2.6636e-13,          7.645e-14,
                            -2.313e-14,           7.33e-15,
                            -2.42e-15,            8.3e-16,
                            -3e-16,               1.1e-16,
                            -4e-17,               2e-17,-1e-17 };

   const Double_t c0  = 2/TMath::Pi();
   const Double_t cc  = 2/(3*TMath::Pi());

   Int_t i, i1;
   Double_t alfa, h, r, y, b0, b1, b2;
   Double_t v = TMath::Abs(x);

   if (v == 0) {
      h = 0;
   } else if (v <= 0.3) {
      y = v*v;
      r = 1;
      h = 1;
      i1 = (Int_t)(-8. / TMath::Log10(v));
      for (i = 1; i <= i1; ++i) {
         h = -h*y / ((2*i+ 1)*(2*i + 3));
         r += h;
      }
      h = cc*y*r;
   } else if (v < 8) {
      h = v*v/32 -1;
      alfa = h + h;
      b0 = 0;
      b1 = 0;
      b2 = 0;
      for (i = n3; i >= 0; --i) {
         b0 = c3[i] + alfa*b1 - b2;
         b2 = b1;
         b1 = b0;
      }
      h = b0 - h*b2;
   } else {
      h = 128/(v*v) -1;
      alfa = h + h;
      b0 = 0;
      b1 = 0;
      b2 = 0;
      for (i = n4; i >= 0; --i) {
         b0 = c4[i] + alfa*b1 - b2;
         b2 = b1;
         b1 = b0;
      }
      h = TMath::BesselY1(v) + c0*(b0 - h*b2);
   }
   return h;
}


//______________________________________________________________________________
Double_t TMath::StruveL0(Double_t x)
{
   // Modified Struve Function of Order 0.
   // By Kirill Filimonov.

   const Double_t pi=TMath::Pi();

   Double_t s=1.0;
   Double_t r=1.0;

   Double_t a0,sl0,a1,bi0;

   Int_t km,i;

   if (x<=20.) {
      a0=2.0*x/pi;
      for (i=1; i<=60;i++) {
         r*=(x/(2*i+1))*(x/(2*i+1));
         s+=r;
         if(TMath::Abs(r/s)<1.e-12) break;
      }
      sl0=a0*s;
   } else {
      km=int(5*(x+1.0));
      if(x>=50.0)km=25;
      for (i=1; i<=km; i++) {
         r*=(2*i-1)*(2*i-1)/x/x;
         s+=r;
         if(TMath::Abs(r/s)<1.0e-12) break;
      }
      a1=TMath::Exp(x)/TMath::Sqrt(2*pi*x);
      r=1.0;
      bi0=1.0;
      for (i=1; i<=16; i++) {
         r=0.125*r*(2.0*i-1.0)*(2.0*i-1.0)/(i*x);
         bi0+=r;
         if(TMath::Abs(r/bi0)<1.0e-12) break;
      }

      bi0=a1*bi0;
      sl0=-2.0/(pi*x)*s+bi0;
   }
   return sl0;
}

//______________________________________________________________________________
Double_t TMath::StruveL1(Double_t x)
{
   // Modified Struve Function of Order 1.
   // By Kirill Filimonov.

   const Double_t pi=TMath::Pi();
   Double_t a1,sl1,bi1,s;
   Double_t r=1.0;
   Int_t km,i;

   if (x<=20.) {
      s=0.0;
      for (i=1; i<=60;i++) {
         r*=x*x/(4.0*i*i-1.0);
         s+=r;
         if(TMath::Abs(r)<TMath::Abs(s)*1.e-12) break;
      }
      sl1=2.0/pi*s;
   } else {
      s=1.0;
      km=int(0.5*x);
      if(x>50.0)km=25;
      for (i=1; i<=km; i++) {
         r*=(2*i+3)*(2*i+1)/x/x;
         s+=r;
         if(TMath::Abs(r/s)<1.0e-12) break;
      }
      sl1=2.0/pi*(-1.0+1.0/(x*x)+3.0*s/(x*x*x*x));
      a1=TMath::Exp(x)/TMath::Sqrt(2*pi*x);
      r=1.0;
      bi1=1.0;
      for (i=1; i<=16; i++) {
         r=-0.125*r*(4.0-(2.0*i-1.0)*(2.0*i-1.0))/(i*x);
         bi1+=r;
         if(TMath::Abs(r/bi1)<1.0e-12) break;
      }
      sl1+=a1*bi1;
   }
   return sl1;
}

//______________________________________________________________________________
Double_t TMath::Beta(Double_t p, Double_t q)
{
   // Calculates Beta-function Gamma(p)*Gamma(q)/Gamma(p+q).

   return ::ROOT::Math::beta(p, q);
}

//______________________________________________________________________________
Double_t TMath::BetaCf(Double_t x, Double_t a, Double_t b)
{
   // Continued fraction evaluation by modified Lentz's method
   // used in calculation of incomplete Beta function.

   Int_t itmax = 500;
   Double_t eps = 3.e-14;
   Double_t fpmin = 1.e-30;

   Int_t m, m2;
   Double_t aa, c, d, del, qab, qam, qap;
   Double_t h;
   qab = a+b;
   qap = a+1.0;
   qam = a-1.0;
   c = 1.0;
   d = 1.0 - qab*x/qap;
   if (TMath::Abs(d)<fpmin) d=fpmin;
   d=1.0/d;
   h=d;
   for (m=1; m<=itmax; m++) {
      m2=m*2;
      aa = m*(b-m)*x/((qam+ m2)*(a+m2));
      d = 1.0 +aa*d;
      if(TMath::Abs(d)<fpmin) d = fpmin;
      c = 1 +aa/c;
      if (TMath::Abs(c)<fpmin) c = fpmin;
      d=1.0/d;
      h*=d*c;
      aa = -(a+m)*(qab +m)*x/((a+m2)*(qap+m2));
      d=1.0+aa*d;
      if(TMath::Abs(d)<fpmin) d = fpmin;
      c = 1.0 +aa/c;
      if (TMath::Abs(c)<fpmin) c = fpmin;
      d=1.0/d;
      del = d*c;
      h*=del;
      if (TMath::Abs(del-1)<=eps) break;
   }
   if (m>itmax) {
      Info("TMath::BetaCf", "a or b too big, or itmax too small, a=%g, b=%g, x=%g, h=%g, itmax=%d",
           a,b,x,h,itmax);
   }
   return h;
}

//______________________________________________________________________________
Double_t TMath::BetaDist(Double_t x, Double_t p, Double_t q)
{
   // Computes the probability density function of the Beta distribution
   // (the distribution function is computed in BetaDistI).
   // The first argument is the point, where the function will be
   // computed, second and third are the function parameters.
   // Since the Beta distribution is bounded on both sides, it's often
   // used to represent processes with natural lower and upper limits.

   if ((x<0) || (x>1) || (p<=0) || (q<=0)){
      Error("TMath::BetaDist", "parameter value outside allowed range");
      return 0;
   }
   Double_t beta = TMath::Beta(p, q);
   Double_t r = TMath::Power(x, p-1)*TMath::Power(1-x, q-1)/beta;
   return r;
}

//______________________________________________________________________________
Double_t TMath::BetaDistI(Double_t x, Double_t p, Double_t q)
{
   // Computes the distribution function of the Beta distribution.
   // The first argument is the point, where the function will be
   // computed, second and third are the function parameters.
   // Since the Beta distribution is bounded on both sides, it's often
   // used to represent processes with natural lower and upper limits.

   if ((x<0) || (x>1) || (p<=0) || (q<=0)){
      Error("TMath::BetaDistI", "parameter value outside allowed range");
      return 0;
   }
   Double_t betai = TMath::BetaIncomplete(x, p, q);
   return betai;
}

//______________________________________________________________________________
Double_t TMath::BetaIncomplete(Double_t x, Double_t a, Double_t b)
{
   // Calculates the incomplete Beta-function.

   return ::ROOT::Math::inc_beta(x, a, b);
}

//______________________________________________________________________________
Double_t TMath::Binomial(Int_t n,Int_t k)
{
   // Calculate the binomial coefficient n over k.

   if (k==0 || n==k) return 1;
   if (n<=0 || k<0 || n<k) return 0;

   Int_t k1=TMath::Min(k,n-k);
   Int_t k2=n-k1;
   Double_t fact=k2+1;
   for (Double_t i=k1;i>1.;--i)
      fact *= (k2+i)/i;
   return fact;
}

//______________________________________________________________________________
Double_t TMath::BinomialI(Double_t p, Int_t n, Int_t k)
{
   // Suppose an event occurs with probability _p_ per trial
   // Then the probability P of its occuring _k_ or more times
   // in _n_ trials is termed a cumulative binomial probability
   // the formula is P = sum_from_j=k_to_n(TMath::Binomial(n, j)*
   // *TMath::Power(p, j)*TMath::Power(1-p, n-j)
   // For _n_ larger than 12 BetaIncomplete is a much better way
   // to evaluate the sum than would be the straightforward sum calculation
   // for _n_ smaller than 12 either method is acceptable
   // ("Numerical Recipes")
   //     --implementation by Anna Kreshuk

   if(k <= 0) return 1.0;
   if(k > n) return 0.0;
   if(k == n) return TMath::Power(p, n);

   return BetaIncomplete(p, Double_t(k), Double_t(n-k+1));
}

//______________________________________________________________________________
Double_t TMath::CauchyDist(Double_t x, Double_t t, Double_t s)
{
   // Computes the density of Cauchy distribution at point x
   // by default, standard Cauchy distribution is used (t=0, s=1)
   //    t is the location parameter
   //    s is the scale parameter
   // The Cauchy distribution, also called Lorentzian distribution,
   // is a continuous distribution describing resonance behavior
   // The mean and standard deviation of the Cauchy distribution are undefined.
   // The practical meaning of this is that collecting 1,000 data points gives
   // no more accurate an estimate of the mean and standard deviation than
   // does a single point.
   // The formula was taken from "Engineering Statistics Handbook" on site
   // http://www.itl.nist.gov/div898/handbook/eda/section3/eda3663.htm
   // Implementation by Anna Kreshuk.
   // Example:
   //    TF1* fc = new TF1("fc", "TMath::CauchyDist(x, [0], [1])", -5, 5);
   //    fc->SetParameters(0, 1);
   //    fc->Draw();

   Double_t temp= (x-t)*(x-t)/(s*s);
   Double_t result = 1/(s*TMath::Pi()*(1+temp));
   return result;
}

//______________________________________________________________________________
Double_t TMath::ChisquareQuantile(Double_t p, Double_t ndf)
{
   // Evaluate the quantiles of the chi-squared probability distribution function.
   // Algorithm AS 91   Appl. Statist. (1975) Vol.24, P.35
   // implemented by Anna Kreshuk.
   // Incorporates the suggested changes in AS R85 (vol.40(1), pp.233-5, 1991)
   // Parameters:
   //   p   - the probability value, at which the quantile is computed
   //   ndf - number of degrees of freedom

   Double_t c[]={0, 0.01, 0.222222, 0.32, 0.4, 1.24, 2.2,
                 4.67, 6.66, 6.73, 13.32, 60.0, 70.0,
                 84.0, 105.0, 120.0, 127.0, 140.0, 175.0,
                 210.0, 252.0, 264.0, 294.0, 346.0, 420.0,
                 462.0, 606.0, 672.0, 707.0, 735.0, 889.0,
                 932.0, 966.0, 1141.0, 1182.0, 1278.0, 1740.0,
                 2520.0, 5040.0};
   Double_t e = 5e-7;
   Double_t aa = 0.6931471806;
   Int_t maxit = 20;
   Double_t ch, p1, p2, q, t, a, b, x;
   Double_t s1, s2, s3, s4, s5, s6;

   if (ndf <= 0) return 0;

   Double_t g = TMath::LnGamma(0.5*ndf);

   Double_t xx = 0.5 * ndf;
   Double_t cp = xx - 1;
   if (ndf >= TMath::Log(p)*(-c[5])){
   //starting approximation for ndf less than or equal to 0.32
      if (ndf > c[3]) {
         x = TMath::NormQuantile(p);
         //starting approximation using Wilson and Hilferty estimate
         p1=c[2]/ndf;
         ch = ndf*TMath::Power((x*TMath::Sqrt(p1) + 1 - p1), 3);
         if (ch > c[6]*ndf + 6)
            ch = -2 * (TMath::Log(1-p) - cp * TMath::Log(0.5 * ch) + g);
      } else {
         ch = c[4];
         a = TMath::Log(1-p);
         do{
            q = ch;
            p1 = 1 + ch * (c[7]+ch);
            p2 = ch * (c[9] + ch * (c[8] + ch));
            t = -0.5 + (c[7] + 2 * ch) / p1 - (c[9] + ch * (c[10] + 3 * ch)) / p2;
            ch = ch - (1 - TMath::Exp(a + g + 0.5 * ch + cp * aa) *p2 / p1) / t;
         }while (TMath::Abs(q/ch - 1) > c[1]);
      }
   } else {
      ch = TMath::Power((p * xx * TMath::Exp(g + xx * aa)),(1./xx));
      if (ch < e) return ch;
   }
//call to algorithm AS 239 and calculation of seven term  Taylor series
   for (Int_t i=0; i<maxit; i++){
      q = ch;
      p1 = 0.5 * ch;
      p2 = p - TMath::Gamma(xx, p1);

      t = p2 * TMath::Exp(xx * aa + g + p1 - cp * TMath::Log(ch));
      b = t / ch;
      a = 0.5 * t - b * cp;
      s1 = (c[19] + a * (c[17] + a * (c[14] + a * (c[13] + a * (c[12] +c[11] * a))))) / c[24];
      s2 = (c[24] + a * (c[29] + a * (c[32] + a * (c[33] + c[35] * a)))) / c[37];
      s3 = (c[19] + a * (c[25] + a * (c[28] + c[31] * a))) / c[37];
      s4 = (c[20] + a * (c[27] + c[34] * a) + cp * (c[22] + a * (c[30] + c[36] * a))) / c[38];
      s5 = (c[13] + c[21] * a + cp * (c[18] + c[26] * a)) / c[37];
      s6 = (c[15] + cp * (c[23] + c[16] * cp)) / c[38];
      ch = ch + t * (1 + 0.5 * t * s1 - b * cp * (s1 - b * (s2 - b * (s3 - b * (s4 - b * (s5 - b * s6))))));
      if (TMath::Abs(q / ch - 1) > e) break;
   }
   return ch;
}

//______________________________________________________________________________
Double_t TMath::FDist(Double_t F, Double_t N, Double_t M)
{
   // Computes the density function of F-distribution
   // (probability function, integral of density, is computed in FDistI).
   //
   // Parameters N and M stand for degrees of freedom of chi-squares
   // mentioned above parameter F is the actual variable x of the
   // density function p(x) and the point at which the density function
   // is calculated.
   //
   // About F distribution:
   // F-distribution arises in testing whether two random samples
   // have the same variance. It is the ratio of two chi-square
   // distributions, with N and M degrees of freedom respectively,
   // where each chi-square is first divided by it's number of degrees
   // of freedom.
   // Implementation by Anna Kreshuk.
   
   return ::ROOT::Math::fdistribution_pdf(F,N,M);
}

//______________________________________________________________________________
Double_t TMath::FDistI(Double_t F, Double_t N, Double_t M)
{
   // Calculates the cumulative distribution function of F-distribution,
   // this function occurs in the statistical test of whether two observed
   // samples have the same variance. For this test a certain statistic F,
   // the ratio of observed dispersion of the first sample to that of the
   // second sample, is calculated. N and M stand for numbers of degrees
   // of freedom in the samples 1-FDistI() is the significance level at
   // which the hypothesis "1 has smaller variance than 2" can be rejected.
   // A small numerical value of 1 - FDistI() implies a very significant
   // rejection, in turn implying high confidence in the hypothesis
   // "1 has variance greater than 2".
   // Implementation by Anna Kreshuk.

   Double_t fi = ::ROOT::Math::fdistribution_cdf(F,N,M);
   return fi;
}

//______________________________________________________________________________
Double_t TMath::GammaDist(Double_t x, Double_t gamma, Double_t mu, Double_t beta)
{
   // Computes the density function of Gamma distribution at point x.
   //   gamma - shape parameter
   //   mu    - location parameter
   //   beta  - scale parameter
   //
   // The definition can be found in "Engineering Statistics Handbook" on site
   // http://www.itl.nist.gov/div898/handbook/eda/section3/eda366b.htm
   // use now implementation in ROOT::Math::gamma_pdf 
   //Begin_Html
   /*
   <img src="gif/gammadist.gif">
   */
   //End_Html

   if ((x<mu) || (gamma<=0) || (beta <=0)) {
      Error("TMath::GammaDist", "illegal parameter values");
      return 0;
   }
   return ::ROOT::Math::gamma_pdf(x, gamma, beta, mu); 
}

//______________________________________________________________________________
Double_t TMath::LaplaceDist(Double_t x, Double_t alpha, Double_t beta)
{
   // Computes the probability density function of Laplace distribution
   // at point x, with location parameter alpha and shape parameter beta.
   // By default, alpha=0, beta=1
   // This distribution is known under different names, most common is
   // double exponential distribution, but it also appears as
   // the two-tailed exponential or the bilateral exponential distribution
   Double_t temp;
   temp  = TMath::Exp(-TMath::Abs((x-alpha)/beta));
   temp /= (2.*beta);
   return temp;
}

//______________________________________________________________________________
Double_t TMath::LaplaceDistI(Double_t x, Double_t alpha, Double_t beta)
{
   // Computes the distribution function of Laplace distribution
   // at point x, with location parameter alpha and shape parameter beta.
   // By default, alpha=0, beta=1
   // This distribution is known under different names, most common is
   // double exponential distribution, but it also appears as
   // the two-tailed exponential or the bilateral exponential distribution

   Double_t temp;
   if (x<=alpha){
      temp = 0.5*TMath::Exp(-TMath::Abs((x-alpha)/beta));
   } else {
      temp = 1-0.5*TMath::Exp(-TMath::Abs((x-alpha)/beta));
   }
   return temp;
}

//______________________________________________________________________________
Double_t TMath::LogNormal(Double_t x, Double_t sigma, Double_t theta, Double_t m)
{
   // Computes the density of LogNormal distribution at point x.
   // Variable X has lognormal distribution if Y=Ln(X) has normal distribution
   // sigma is the shape parameter
   // theta is the location parameter
   // m is the scale parameter
   // The formula was taken from "Engineering Statistics Handbook" on site
   // http://www.itl.nist.gov/div898/handbook/eda/section3/eda3669.htm
   // Implementation using ROOT::Math::lognormal_pdf
   //Begin_Html
   /*
   <img src="gif/lognormal.gif">
   */
   //End_Html

   if ((x<theta) || (sigma<=0) || (m<=0)) {
      Error("TMath::Lognormal", "illegal parameter values");
      return 0;
   }
   // lognormal_pdf uses same definition of http://en.wikipedia.org/wiki/Log-normal_distribution
   // where mu = log(m)
   
   return ::ROOT::Math::lognormal_pdf(x, TMath::Log(m), sigma, theta); 

}

//______________________________________________________________________________
Double_t TMath::NormQuantile(Double_t p)
{
   // Computes quantiles for standard normal distribution N(0, 1)
   // at probability p
   // ALGORITHM AS241  APPL. STATIST. (1988) VOL. 37, NO. 3, 477-484.

   if ((p<=0)||(p>=1)) {
      Error("TMath::NormQuantile", "probability outside (0, 1)");
      return 0;
   }

   Double_t  a0 = 3.3871328727963666080e0;
   Double_t  a1 = 1.3314166789178437745e+2;
   Double_t  a2 = 1.9715909503065514427e+3;
   Double_t  a3 = 1.3731693765509461125e+4;
   Double_t  a4 = 4.5921953931549871457e+4;
   Double_t  a5 = 6.7265770927008700853e+4;
   Double_t  a6 = 3.3430575583588128105e+4;
   Double_t  a7 = 2.5090809287301226727e+3;
   Double_t  b1 = 4.2313330701600911252e+1;
   Double_t  b2 = 6.8718700749205790830e+2;
   Double_t  b3 = 5.3941960214247511077e+3;
   Double_t  b4 = 2.1213794301586595867e+4;
   Double_t  b5 = 3.9307895800092710610e+4;
   Double_t  b6 = 2.8729085735721942674e+4;
   Double_t  b7 = 5.2264952788528545610e+3;
   Double_t  c0 = 1.42343711074968357734e0;
   Double_t  c1 = 4.63033784615654529590e0;
   Double_t  c2 = 5.76949722146069140550e0;
   Double_t  c3 = 3.64784832476320460504e0;
   Double_t  c4 = 1.27045825245236838258e0;
   Double_t  c5 = 2.41780725177450611770e-1;
   Double_t  c6 = 2.27238449892691845833e-2;
   Double_t  c7 = 7.74545014278341407640e-4;
   Double_t  d1 = 2.05319162663775882187e0;
   Double_t  d2 = 1.67638483018380384940e0;
   Double_t  d3 = 6.89767334985100004550e-1;
   Double_t  d4 = 1.48103976427480074590e-1;
   Double_t  d5 = 1.51986665636164571966e-2;
   Double_t  d6 = 5.47593808499534494600e-4;
   Double_t  d7 = 1.05075007164441684324e-9;
   Double_t  e0 = 6.65790464350110377720e0;
   Double_t  e1 = 5.46378491116411436990e0;
   Double_t  e2 = 1.78482653991729133580e0;
   Double_t  e3 = 2.96560571828504891230e-1;
   Double_t  e4 = 2.65321895265761230930e-2;
   Double_t  e5 = 1.24266094738807843860e-3;
   Double_t  e6 = 2.71155556874348757815e-5;
   Double_t  e7 = 2.01033439929228813265e-7;
   Double_t  f1 = 5.99832206555887937690e-1;
   Double_t  f2 = 1.36929880922735805310e-1;
   Double_t  f3 = 1.48753612908506148525e-2;
   Double_t  f4 = 7.86869131145613259100e-4;
   Double_t  f5 = 1.84631831751005468180e-5;
   Double_t  f6 = 1.42151175831644588870e-7;
   Double_t  f7 = 2.04426310338993978564e-15;

   Double_t split1 = 0.425;
   Double_t split2=5.;
   Double_t konst1=0.180625;
   Double_t konst2=1.6;

   Double_t q, r, quantile;
   q=p-0.5;
   if (TMath::Abs(q)<split1) {
      r=konst1-q*q;
      quantile = q* (((((((a7 * r + a6) * r + a5) * r + a4) * r + a3)
                 * r + a2) * r + a1) * r + a0) /
                 (((((((b7 * r + b6) * r + b5) * r + b4) * r + b3)
                 * r + b2) * r + b1) * r + 1.);
   } else {
      if(q<0) r=p;
      else    r=1-p;
      //error case
      if (r<=0)
         quantile=0;
      else {
         r=TMath::Sqrt(-TMath::Log(r));
         if (r<=split2) {
            r=r-konst2;
            quantile=(((((((c7 * r + c6) * r + c5) * r + c4) * r + c3)
                     * r + c2) * r + c1) * r + c0) /
                     (((((((d7 * r + d6) * r + d5) * r + d4) * r + d3)
                     * r + d2) * r + d1) * r + 1);
         } else{
            r=r-split2;
            quantile=(((((((e7 * r + e6) * r + e5) * r + e4) * r + e3)
                     * r + e2) * r + e1) * r + e0) /
                     (((((((f7 * r + f6) * r + f5) * r + f4) * r + f3)
                     * r + f2) * r + f1) * r + 1);
         }
         if (q<0) quantile=-quantile;
      }
   }
   return quantile;
}

//______________________________________________________________________________
Bool_t TMath::Permute(Int_t n, Int_t *a)
{
   // Simple recursive algorithm to find the permutations of
   // n natural numbers, not necessarily all distinct
   // adapted from CERNLIB routine PERMU.
   // The input array has to be initialised with a non descending
   // sequence. The method returns kFALSE when
   // all combinations are exhausted.

   Int_t i,itmp;
   Int_t i1=-1;

   // find rightmost upward transition
   for(i=n-2; i>-1; i--) {
      if(a[i]<a[i+1]) {
         i1=i;
         break;
      }
   }
   // no more upward transitions, end of the story
   if(i1==-1) return kFALSE;
   else {
      // find lower right element higher than the lower
      // element of the upward transition
      for(i=n-1;i>i1;i--) {
         if(a[i] > a[i1]) {
            // swap the two
            itmp=a[i1];
            a[i1]=a[i];
            a[i]=itmp;
            break;
         }
      }
      // order the rest, in fact just invert, as there
      // are only downward transitions from here on
      for(i=0;i<(n-i1-1)/2;i++) {
         itmp=a[i1+i+1];
         a[i1+i+1]=a[n-i-1];
         a[n-i-1]=itmp;
      }
   }
   return kTRUE;
}

//______________________________________________________________________________
Double_t TMath::Student(Double_t T, Double_t ndf)
{
   // Computes density function for Student's t- distribution
   // (the probability function (integral of density) is computed in StudentI).
   //
   // First parameter stands for x - the actual variable of the
   // density function p(x) and the point at which the density is calculated.
   // Second parameter stands for number of degrees of freedom.
   //
   // About Student distribution:
   // Student's t-distribution is used for many significance tests, for example,
   // for the Student's t-tests for the statistical significance of difference
   // between two sample means and for confidence intervals for the difference
   // between two population means.
   //
   // Example: suppose we have a random sample of size n drawn from normal
   // distribution with mean Mu and st.deviation Sigma. Then the variable
   //
   //   t = (sample_mean - Mu)/(sample_deviation / sqrt(n))
   //
   // has Student's t-distribution with n-1 degrees of freedom.
   //
   // NOTE that this function's second argument is number of degrees of freedom,
   // not the sample size.
   //
   // As the number of degrees of freedom grows, t-distribution approaches
   // Normal(0,1) distribution.
   // Implementation by Anna Kreshuk.

   if (ndf < 1) {
      return 0;
   }

   Double_t r   = ndf;
   Double_t rh  = 0.5*r;
   Double_t rh1 = rh + 0.5;
   Double_t denom = TMath::Sqrt(r*TMath::Pi())*TMath::Gamma(rh)*TMath::Power(1+T*T/r, rh1);
   return TMath::Gamma(rh1)/denom;
}

//______________________________________________________________________________
Double_t TMath::StudentI(Double_t T, Double_t ndf)
{
   // Calculates the cumulative distribution function of Student's
   // t-distribution second parameter stands for number of degrees of freedom,
   // not for the number of samples
   // if x has Student's t-distribution, the function returns the probability of
   // x being less than T.
   // Implementation by Anna Kreshuk.

   Double_t r = ndf;

   Double_t si = (T>0) ?
                 (1 - 0.5*BetaIncomplete((r/(r + T*T)), r*0.5, 0.5)) :
                 0.5*BetaIncomplete((r/(r + T*T)), r*0.5, 0.5);
   return si;
}

//______________________________________________________________________________
Double_t TMath::StudentQuantile(Double_t p, Double_t ndf, Bool_t lower_tail)
{
   // Computes quantiles of the Student's t-distribution
   // 1st argument is the probability, at which the quantile is computed
   // 2nd argument - the number of degrees of freedom of the
   // Student distribution
   // When the 3rd argument lower_tail is kTRUE (default)-
   // the algorithm returns such x0, that
   //   P(x < x0)=p
   // upper tail (lower_tail is kFALSE)- the algorithm returns such x0, that
   //   P(x > x0)=p
   // the algorithm was taken from
   //   G.W.Hill, "Algorithm 396, Student's t-quantiles"
   //             "Communications of the ACM", 13(10), October 1970

   Double_t quantile;
   Double_t temp;
   Bool_t neg;
   Double_t q;
   if (ndf<1 || p>=1 || p<=0) {
      Error("TMath::StudentQuantile", "illegal parameter values");
      return 0;
   }
   if ((lower_tail && p>0.5)||(!lower_tail && p<0.5)){
      neg=kFALSE;
      q=2*(lower_tail ? (1-p) : p);
   } else {
      neg=kTRUE;
      q=2*(lower_tail? p : (1-p));
   }

   if ((ndf-1)<1e-8) {
      temp=TMath::PiOver2()*q;
      quantile = TMath::Cos(temp)/TMath::Sin(temp);
   } else {
      if ((ndf-2)<1e-8) {
         quantile = TMath::Sqrt(2./(q*(2-q))-2);
      } else {
         Double_t a=1./(ndf-0.5);
         Double_t b=48./(a*a);
         Double_t c=((20700*a/b -98)*a-16)*a+96.36;
         Double_t d=((94.5/(b+c)-3.)/b+1)*TMath::Sqrt(a*TMath::PiOver2())*ndf;
         Double_t x=q*d;
         Double_t y=TMath::Power(x, (2./ndf));
         if (y>0.05+a){
            //asymptotic inverse expansion about normal
            x=TMath::NormQuantile(q*0.5);
            y=x*x;
            if (ndf<5) c+=0.3*(ndf-4.5)*(x+0.6);
            c+=(((0.05*d*x-5.)*x-7.)*x-2.)*x +b;
            y=(((((0.4*y+6.3)*y+36.)*y+94.5)/c - y-3.)/b+1)*x;
            y=a*y*y;
            if(y>0.002) y  = TMath::Exp(y)-1;
            else        y += 0.5*y*y;
         } else {
            y=((1./(((ndf+6.)/(ndf*y)-0.089*d-0.822)*(ndf+2.)*3)+0.5/(ndf+4.))*y-1.)*
              (ndf+1.)/(ndf+2.)+1/y;
         }
         quantile = TMath::Sqrt(ndf*y);
      }
   }
   if(neg) quantile=-quantile;
   return quantile;
}

//______________________________________________________________________________
Double_t TMath::Vavilov(Double_t x, Double_t kappa, Double_t beta2)
{
   //Returns the value of the Vavilov density function
   //Parameters: 1st - the point were the density function is evaluated
   //            2nd - value of kappa (distribution parameter)
   //            3rd - value of beta2 (distribution parameter)
   //The algorithm was taken from the CernLib function vavden(G115)
   //Reference: A.Rotondi and P.Montagna, Fast Calculation of Vavilov distribution
   //Nucl.Instr. and Meth. B47(1990), 215-224
   //Accuracy: quote from the reference above:
   //"The resuls of our code have been compared with the values of the Vavilov
   //density function computed numerically in an accurate way: our approximation
   //shows a difference of less than 3% around the peak of the density function, slowly
   //increasing going towards the extreme tails to the right and to the left"
//Begin_Html
/*
<img src="gif/Vavilov.gif">
*/
//End_Html

   Double_t *ac = new Double_t[14];
   Double_t *hc = new Double_t[9];

   Int_t itype;
   Int_t npt;
   TMath::VavilovSet(kappa, beta2, 0, 0, ac, hc, itype, npt);
   Double_t v =  TMath::VavilovDenEval(x, ac, hc, itype);
   delete [] ac;
   delete [] hc;
   return v;
}

//______________________________________________________________________________
Double_t TMath::VavilovI(Double_t x, Double_t kappa, Double_t beta2)
{
   //Returns the value of the Vavilov distribution function
   //Parameters: 1st - the point were the density function is evaluated
   //            2nd - value of kappa (distribution parameter)
   //            3rd - value of beta2 (distribution parameter)
   //The algorithm was taken from the CernLib function vavden(G115)
   //Reference: A.Rotondi and P.Montagna, Fast Calculation of Vavilov distribution
   //Nucl.Instr. and Meth. B47(1990), 215-224
   //Accuracy: quote from the reference above:
   //"The resuls of our code have been compared with the values of the Vavilov
   //density function computed numerically in an accurate way: our approximation
   //shows a difference of less than 3% around the peak of the density function, slowly
   //increasing going towards the extreme tails to the right and to the left"

   Double_t *ac = new Double_t[14];
   Double_t *hc = new Double_t[9];
   Double_t *wcm = new Double_t[201];
   Int_t itype;
   Int_t npt;
   Int_t k;
   Double_t xx, v;
   TMath::VavilovSet(kappa, beta2, 1, wcm, ac, hc, itype, npt);
   if (x < ac[0]) v = 0;
   else if (x >=ac[8]) v = 1;
   else {
      xx = x - ac[0];
      k = Int_t(xx*ac[10]);
      v = TMath::Min(wcm[k] + (xx - k*ac[9])*(wcm[k+1]-wcm[k])*ac[10], 1.);
   }
   delete [] ac;
   delete [] hc;
   delete [] wcm;
   return v;
}

//______________________________________________________________________________
Double_t TMath::LandauI(Double_t x)
{
   //Returns the value of the Landau distribution function at point x.
   //The algorithm was taken from the Cernlib function dislan(G110)
   //Reference: K.S.Kolbig and B.Schorr, "A program package for the Landau
   //distribution", Computer Phys.Comm., 31(1984), 97-111
   
   return ::ROOT::Math::landau_cdf(x);
}


//______________________________________________________________________________
void TMath::VavilovSet(Double_t rkappa, Double_t beta2, Bool_t mode, Double_t *WCM, Double_t *AC, Double_t *HC, Int_t &itype, Int_t &npt)
{
   //Internal function, called by Vavilov and VavilovI


   Double_t BKMNX1 = 0.02, BKMNY1 = 0.05, BKMNX2 = 0.12, BKMNY2 = 0.05,
      BKMNX3 = 0.22, BKMNY3 = 0.05, BKMXX1 = 0.1 , BKMXY1 = 1,
      BKMXX2 = 0.2 , BKMXY2 = 1   , BKMXX3 = 0.3 , BKMXY3 = 1;

   Double_t FBKX1 = 2/(BKMXX1-BKMNX1), FBKX2 = 2/(BKMXX2-BKMNX2),
      FBKX3 = 2/(BKMXX3-BKMNX3), FBKY1 = 2/(BKMXY1-BKMNY1),
      FBKY2 = 2/(BKMXY2-BKMNY2), FBKY3 = 2/(BKMXY3-BKMNY3);

   Double_t FNINV[] = {0, 1, 0.5, 0.33333333, 0.25, 0.2};

   Double_t EDGEC[]= {0, 0, 0.16666667e+0, 0.41666667e-1, 0.83333333e-2,
                      0.13888889e-1, 0.69444444e-2, 0.77160493e-3};

   Double_t U1[] = {0, 0.25850868e+0,  0.32477982e-1, -0.59020496e-2,
                    0.            , 0.24880692e-1,  0.47404356e-2,
                    -0.74445130e-3,  0.73225731e-2,  0.           ,
                    0.11668284e-2,  0.           , -0.15727318e-2,-0.11210142e-2};

   Double_t U2[] = {0, 0.43142611e+0,  0.40797543e-1, -0.91490215e-2,
                    0.           ,  0.42127077e-1,  0.73167928e-2,
                    -0.14026047e-2,  0.16195241e-1,  0.24714789e-2,
                    0.20751278e-2,  0.           , -0.25141668e-2,-0.14064022e-2};

   Double_t U3[] = {0,  0.25225955e+0,  0.64820468e-1, -0.23615759e-1,
                    0.           ,  0.23834176e-1,  0.21624675e-2,
                    -0.26865597e-2, -0.54891384e-2,  0.39800522e-2,
                    0.48447456e-2, -0.89439554e-2, -0.62756944e-2,-0.24655436e-2};

   Double_t U4[] = {0, 0.12593231e+1, -0.20374501e+0,  0.95055662e-1,
                    -0.20771531e-1, -0.46865180e-1, -0.77222986e-2,
                    0.32241039e-2,  0.89882920e-2, -0.67167236e-2,
                    -0.13049241e-1,  0.18786468e-1,  0.14484097e-1};

   Double_t U5[] = {0, -0.24864376e-1, -0.10368495e-2,  0.14330117e-2,
                    0.20052730e-3,  0.18751903e-2,  0.12668869e-2,
                    0.48736023e-3,  0.34850854e-2,  0.           ,
                    -0.36597173e-3,  0.19372124e-2,  0.70761825e-3, 0.46898375e-3};

   Double_t U6[] = {0,  0.35855696e-1, -0.27542114e-1,  0.12631023e-1,
                    -0.30188807e-2, -0.84479939e-3,  0.           ,
                    0.45675843e-3, -0.69836141e-2,  0.39876546e-2,
                    -0.36055679e-2,  0.           ,  0.15298434e-2, 0.19247256e-2};

   Double_t U7[] = {0, 0.10234691e+2, -0.35619655e+1,  0.69387764e+0,
                    -0.14047599e+0, -0.19952390e+1, -0.45679694e+0,
                    0.           ,  0.50505298e+0};
   Double_t U8[] = {0,  0.21487518e+2, -0.11825253e+2,  0.43133087e+1,
                    -0.14500543e+1, -0.34343169e+1, -0.11063164e+1,
                    -0.21000819e+0,  0.17891643e+1, -0.89601916e+0,
                    0.39120793e+0,  0.73410606e+0,  0.           ,-0.32454506e+0};

   Double_t V1[] = {0, 0.27827257e+0, -0.14227603e-2,  0.24848327e-2,
                    0.           ,  0.45091424e-1,  0.80559636e-2,
                    -0.38974523e-2,  0.           , -0.30634124e-2,
                    0.75633702e-3,  0.54730726e-2,  0.19792507e-2};

   Double_t V2[] = {0, 0.41421789e+0, -0.30061649e-1,  0.52249697e-2,
                    0.           ,  0.12693873e+0,  0.22999801e-1,
                    -0.86792801e-2,  0.31875584e-1, -0.61757928e-2,
                    0.           ,  0.19716857e-1,  0.32596742e-2};

   Double_t V3[] = {0, 0.20191056e+0, -0.46831422e-1,  0.96777473e-2,
                    -0.17995317e-2,  0.53921588e-1,  0.35068740e-2,
                    -0.12621494e-1, -0.54996531e-2, -0.90029985e-2,
                    0.34958743e-2,  0.18513506e-1,  0.68332334e-2,-0.12940502e-2};

   Double_t V4[] = {0, 0.13206081e+1,  0.10036618e+0, -0.22015201e-1,
                    0.61667091e-2, -0.14986093e+0, -0.12720568e-1,
                    0.24972042e-1, -0.97751962e-2,  0.26087455e-1,
                    -0.11399062e-1, -0.48282515e-1, -0.98552378e-2};

   Double_t V5[] = {0, 0.16435243e-1,  0.36051400e-1,  0.23036520e-2,
                    -0.61666343e-3, -0.10775802e-1,  0.51476061e-2,
                    0.56856517e-2, -0.13438433e-1,  0.           ,
                    0.           , -0.25421507e-2,  0.20169108e-2,-0.15144931e-2};

   Double_t V6[] = {0, 0.33432405e-1,  0.60583916e-2, -0.23381379e-2,
                    0.83846081e-3, -0.13346861e-1, -0.17402116e-2,
                    0.21052496e-2,  0.15528195e-2,  0.21900670e-2,
                    -0.13202847e-2, -0.45124157e-2, -0.15629454e-2, 0.22499176e-3};

   Double_t V7[] = {0, 0.54529572e+1, -0.90906096e+0,  0.86122438e-1,
                    0.           , -0.12218009e+1, -0.32324120e+0,
                    -0.27373591e-1,  0.12173464e+0,  0.           ,
                    0.           ,  0.40917471e-1};

   Double_t V8[] = {0, 0.93841352e+1, -0.16276904e+1,  0.16571423e+0,
                    0.           , -0.18160479e+1, -0.50919193e+0,
                    -0.51384654e-1,  0.21413992e+0,  0.           ,
                    0.           ,  0.66596366e-1};

   Double_t W1[] = {0, 0.29712951e+0,  0.97572934e-2,  0.           ,
                    -0.15291686e-2,  0.35707399e-1,  0.96221631e-2,
                    -0.18402821e-2, -0.49821585e-2,  0.18831112e-2,
                    0.43541673e-2,  0.20301312e-2, -0.18723311e-2,-0.73403108e-3};

   Double_t W2[] = {0, 0.40882635e+0,  0.14474912e-1,  0.25023704e-2,
                    -0.37707379e-2,  0.18719727e+0,  0.56954987e-1,
                    0.           ,  0.23020158e-1,  0.50574313e-2,
                    0.94550140e-2,  0.19300232e-1};

   Double_t W3[] = {0, 0.16861629e+0,  0.           ,  0.36317285e-2,
                    -0.43657818e-2,  0.30144338e-1,  0.13891826e-1,
                    -0.58030495e-2, -0.38717547e-2,  0.85359607e-2,
                    0.14507659e-1,  0.82387775e-2, -0.10116105e-1,-0.55135670e-2};

   Double_t W4[] = {0, 0.13493891e+1, -0.26863185e-2, -0.35216040e-2,
                    0.24434909e-1, -0.83447911e-1, -0.48061360e-1,
                    0.76473951e-2,  0.24494430e-1, -0.16209200e-1,
                    -0.37768479e-1, -0.47890063e-1,  0.17778596e-1, 0.13179324e-1};

   Double_t W5[] = {0,  0.10264945e+0,  0.32738857e-1,  0.           ,
                    0.43608779e-2, -0.43097757e-1, -0.22647176e-2,
                    0.94531290e-2, -0.12442571e-1, -0.32283517e-2,
                    -0.75640352e-2, -0.88293329e-2,  0.52537299e-2, 0.13340546e-2};

   Double_t W6[] = {0, 0.29568177e-1, -0.16300060e-2, -0.21119745e-3,
                    0.23599053e-2, -0.48515387e-2, -0.40797531e-2,
                    0.40403265e-3,  0.18200105e-2, -0.14346306e-2,
                    -0.39165276e-2, -0.37432073e-2,  0.19950380e-2, 0.12222675e-2};

   Double_t W8[] = {0,  0.66184645e+1, -0.73866379e+0,  0.44693973e-1,
                    0.           , -0.14540925e+1, -0.39529833e+0,
                    -0.44293243e-1,  0.88741049e-1};

   itype = 0;
   if (rkappa <0.01 || rkappa >12) {
      Error("Vavilov distribution", "illegal value of kappa");
      return;
   }

   Double_t DRK[6];
   Double_t DSIGM[6];
   Double_t ALFA[8];
   Int_t j;
   Double_t x, y, xx, yy, x2, x3, y2, y3, xy, p2, p3, q2, q3, pq;
   if (rkappa >= 0.29) {
      itype = 1;
      npt = 100;
      Double_t wk = 1./TMath::Sqrt(rkappa);

      AC[0] = (-0.032227*beta2-0.074275)*rkappa + (0.24533*beta2+0.070152)*wk + (-0.55610*beta2-3.1579);
      AC[8] = (-0.013483*beta2-0.048801)*rkappa + (-1.6921*beta2+8.3656)*wk + (-0.73275*beta2-3.5226);
      DRK[1] = wk*wk;
      DSIGM[1] = TMath::Sqrt(rkappa/(1-0.5*beta2));
      for (j=1; j<=4; j++) {
         DRK[j+1] = DRK[1]*DRK[j];
         DSIGM[j+1] = DSIGM[1]*DSIGM[j];
         ALFA[j+1] = (FNINV[j]-beta2*FNINV[j+1])*DRK[j];
      }
      HC[0]=TMath::Log(rkappa)+beta2+0.42278434;
      HC[1]=DSIGM[1];
      HC[2]=ALFA[3]*DSIGM[3];
      HC[3]=(3*ALFA[2]*ALFA[2] + ALFA[4])*DSIGM[4]-3;
      HC[4]=(10*ALFA[2]*ALFA[3]+ALFA[5])*DSIGM[5]-10*HC[2];
      HC[5]=HC[2]*HC[2];
      HC[6]=HC[2]*HC[3];
      HC[7]=HC[2]*HC[5];
      for (j=2; j<=7; j++)
         HC[j]*=EDGEC[j];
      HC[8]=0.39894228*HC[1];
   }
   else if (rkappa >=0.22) {
      itype = 2;
      npt = 150;
      x = 1+(rkappa-BKMXX3)*FBKX3;
      y = 1+(TMath::Sqrt(beta2)-BKMXY3)*FBKY3;
      xx = 2*x;
      yy = 2*y;
      x2 = xx*x-1;
      x3 = xx*x2-x;
      y2 = yy*y-1;
      y3 = yy*y2-y;
      xy = x*y;
      p2 = x2*y;
      p3 = x3*y;
      q2 = y2*x;
      q3 = y3*x;
      pq = x2*y2;
      AC[1] = W1[1] + W1[2]*x + W1[4]*x3 + W1[5]*y + W1[6]*y2 + W1[7]*y3 +
         W1[8]*xy + W1[9]*p2 + W1[10]*p3 + W1[11]*q2 + W1[12]*q3 + W1[13]*pq;
      AC[2] = W2[1] + W2[2]*x + W2[3]*x2 + W2[4]*x3 + W2[5]*y + W2[6]*y2 +
         W2[8]*xy + W2[9]*p2 + W2[10]*p3 + W2[11]*q2;
      AC[3] = W3[1] + W3[3]*x2 + W3[4]*x3 + W3[5]*y + W3[6]*y2 + W3[7]*y3 +
         W3[8]*xy + W3[9]*p2 + W3[10]*p3 + W3[11]*q2 + W3[12]*q3 + W3[13]*pq;
      AC[4] = W4[1] + W4[2]*x + W4[3]*x2 + W4[4]*x3 + W4[5]*y + W4[6]*y2 + W4[7]*y3 +
         W4[8]*xy + W4[9]*p2 + W4[10]*p3 + W4[11]*q2 + W4[12]*q3 + W4[13]*pq;
      AC[5] = W5[1] + W5[2]*x + W5[4]*x3 + W5[5]*y + W5[6]*y2 + W5[7]*y3 +
         W5[8]*xy + W5[9]*p2 + W5[10]*p3 + W5[11]*q2 + W5[12]*q3 + W5[13]*pq;
      AC[6] = W6[1] + W6[2]*x + W6[3]*x2 + W6[4]*x3 + W6[5]*y + W6[6]*y2 + W6[7]*y3 +
         W6[8]*xy + W6[9]*p2 + W6[10]*p3 + W6[11]*q2 + W6[12]*q3 + W6[13]*pq;
      AC[8] = W8[1] + W8[2]*x + W8[3]*x2 + W8[5]*y + W8[6]*y2 + W8[7]*y3 + W8[8]*xy;
      AC[0] = -3.05;
   } else if (rkappa >= 0.12) {
      itype = 3;
      npt = 200;
      x = 1 + (rkappa-BKMXX2)*FBKX2;
      y = 1 + (TMath::Sqrt(beta2)-BKMXY2)*FBKY2;
      xx = 2*x;
      yy = 2*y;
      x2 = xx*x-1;
      x3 = xx*x2-x;
      y2 = yy*y-1;
      y3 = yy*y2-y;
      xy = x*y;
      p2 = x2*y;
      p3 = x3*y;
      q2 = y2*x;
      q3 = y3*x;
      pq = x2*y2;
      AC[1] = V1[1] + V1[2]*x + V1[3]*x2 + V1[5]*y + V1[6]*y2 + V1[7]*y3 +
         V1[9]*p2 + V1[10]*p3 + V1[11]*q2 + V1[12]*q3;
      AC[2] = V2[1] + V2[2]*x + V2[3]*x2 + V2[5]*y + V2[6]*y2 + V2[7]*y3 +
         V2[8]*xy + V2[9]*p2 + V2[11]*q2 + V2[12]*q3;
      AC[3] = V3[1] + V3[2]*x + V3[3]*x2 + V3[4]*x3 + V3[5]*y + V3[6]*y2 + V3[7]*y3 +
         V3[8]*xy + V3[9]*p2 + V3[10]*p3 + V3[11]*q2 + V3[12]*q3 + V3[13]*pq;
      AC[4] = V4[1] + V4[2]*x + V4[3]*x2 + V4[4]*x3 + V4[5]*y + V4[6]*y2 + V4[7]*y3 +
         V4[8]*xy + V4[9]*p2 + V4[10]*p3 + V4[11]*q2 + V4[12]*q3;
      AC[5] = V5[1] + V5[2]*x + V5[3]*x2 + V5[4]*x3 + V5[5]*y + V5[6]*y2 + V5[7]*y3 +
         V5[8]*xy + V5[11]*q2 + V5[12]*q3 + V5[13]*pq;
      AC[6] = V6[1] + V6[2]*x + V6[3]*x2 + V6[4]*x3 + V6[5]*y + V6[6]*y2 + V6[7]*y3 +
         V6[8]*xy + V6[9]*p2 + V6[10]*p3 + V6[11]*q2 + V6[12]*q3 + V6[13]*pq;
      AC[7] = V7[1] + V7[2]*x + V7[3]*x2 + V7[5]*y + V7[6]*y2 + V7[7]*y3 +
         V7[8]*xy + V7[11]*q2;
      AC[8] = V8[1] + V8[2]*x + V8[3]*x2 + V8[5]*y + V8[6]*y2 + V8[7]*y3 +
         V8[8]*xy + V8[11]*q2;
      AC[0] = -3.04;
   } else {
      itype = 4;
      if (rkappa >=0.02) itype = 3;
      npt = 200;
      x = 1+(rkappa-BKMXX1)*FBKX1;
      y = 1+(TMath::Sqrt(beta2)-BKMXY1)*FBKY1;
      xx = 2*x;
      yy = 2*y;
      x2 = xx*x-1;
      x3 = xx*x2-x;
      y2 = yy*y-1;
      y3 = yy*y2-y;
      xy = x*y;
      p2 = x2*y;
      p3 = x3*y;
      q2 = y2*x;
      q3 = y3*x;
      pq = x2*y2;
      if (itype==3){
         AC[1] = U1[1] + U1[2]*x + U1[3]*x2 + U1[5]*y + U1[6]*y2 + U1[7]*y3 +
            U1[8]*xy + U1[10]*p3 + U1[12]*q3 + U1[13]*pq;
         AC[2] = U2[1] + U2[2]*x + U2[3]*x2 + U2[5]*y + U2[6]*y2 + U2[7]*y3 +
            U2[8]*xy + U2[9]*p2 + U2[10]*p3 + U2[12]*q3 + U2[13]*pq;
         AC[3] = U3[1] + U3[2]*x + U3[3]*x2 + U3[5]*y + U3[6]*y2 + U3[7]*y3 +
            U3[8]*xy + U3[9]*p2 + U3[10]*p3 + U3[11]*q2 + U3[12]*q3 + U3[13]*pq;
         AC[4] = U4[1] + U4[2]*x + U4[3]*x2 + U4[4]*x3 + U4[5]*y + U4[6]*y2 + U4[7]*y3 +
            U4[8]*xy + U4[9]*p2 + U4[10]*p3 + U4[11]*q2 + U4[12]*q3;
         AC[5] = U5[1] + U5[2]*x + U5[3]*x2 + U5[4]*x3 + U5[5]*y + U5[6]*y2 + U5[7]*y3 +
            U5[8]*xy + U5[10]*p3 + U5[11]*q2 + U5[12]*q3 + U5[13]*pq;
         AC[6] = U6[1] + U6[2]*x + U6[3]*x2 + U6[4]*x3 + U6[5]*y + U6[7]*y3 +
            U6[8]*xy + U6[9]*p2 + U6[10]*p3 + U6[12]*q3 + U6[13]*pq;
         AC[7] = U7[1] + U7[2]*x + U7[3]*x2 + U7[4]*x3 + U7[5]*y + U7[6]*y2 + U7[8]*xy;
      }
      AC[8] = U8[1] + U8[2]*x + U8[3]*x2 + U8[4]*x3 + U8[5]*y + U8[6]*y2 + U8[7]*y3 +
         U8[8]*xy + U8[9]*p2 + U8[10]*p3 + U8[11]*q2 + U8[13]*pq;
      AC[0] = -3.03;
   }

   AC[9] = (AC[8] - AC[0])/npt;
   AC[10] = 1./AC[9];
   if (itype == 3) {
      x = (AC[7]-AC[8])/(AC[7]*AC[8]);
      y = 1./TMath::Log(AC[8]/AC[7]);
      p2 = AC[7]*AC[7];
      AC[11] = p2*(AC[1]*TMath::Exp(-AC[2]*(AC[7]+AC[5]*p2)-
                                    AC[3]*TMath::Exp(-AC[4]*(AC[7]+AC[6]*p2)))-0.045*y/AC[7])/(1+x*y*AC[7]);
      AC[12] = (0.045+x*AC[11])*y;
   }
   if (itype == 4) AC[13] = 0.995/LandauI(AC[8]);

   if (mode==0) return;
   //
   x = AC[0];
   WCM[0] = 0;
   Double_t fl, fu;
   Int_t k;
   fl = TMath::VavilovDenEval(x, AC, HC, itype);
   for (k=1; k<=npt; k++) {
      x += AC[9];
      fu = TMath::VavilovDenEval(x, AC, HC, itype);
      WCM[k] = WCM[k-1] + fl + fu;
      fl = fu;
   }
   x = 0.5*AC[9];
   for (k=1; k<=npt; k++)
      WCM[k]*=x;
}

//______________________________________________________________________________
Double_t TMath::VavilovDenEval(Double_t rlam, Double_t *AC, Double_t *HC, Int_t itype)
{
   //Internal function, called by Vavilov and VavilovSet

   Double_t v = 0;
   if (rlam < AC[0] || rlam > AC[8])
      return 0;
   Int_t k;
   Double_t x, fn, s;
   Double_t h[10];
   if (itype ==1 ) {
      fn = 1;
      x = (rlam + HC[0])*HC[1];
      h[1] = x;
      h[2] = x*x -1;
      for (k=2; k<=8; k++) {
         fn++;
         h[k+1] = x*h[k]-fn*h[k-1];
      }
      s = 1 + HC[7]*h[9];
      for (k=2; k<=6; k++)
         s+=HC[k]*h[k+1];
      v = HC[8]*TMath::Exp(-0.5*x*x)*TMath::Max(s, 0.);
   }
   else if (itype == 2) {
      x = rlam*rlam;
      v = AC[1]*TMath::Exp(-AC[2]*(rlam+AC[5]*x) - AC[3]*TMath::Exp(-AC[4]*(rlam+AC[6]*x)));
   }
   else if (itype == 3) {
      if (rlam < AC[7]) {
         x = rlam*rlam;
         v = AC[1]*TMath::Exp(-AC[2]*(rlam+AC[5]*x)-AC[3]*TMath::Exp(-AC[4]*(rlam+AC[6]*x)));
      } else {
         x = 1./rlam;
         v = (AC[11]*x + AC[12])*x;
      }
   }
   else if (itype == 4) {
      v = AC[13]*TMath::Landau(rlam);
   }
   return v;
}
 TMath.cxx:1
 TMath.cxx:2
 TMath.cxx:3
 TMath.cxx:4
 TMath.cxx:5
 TMath.cxx:6
 TMath.cxx:7
 TMath.cxx:8
 TMath.cxx:9
 TMath.cxx:10
 TMath.cxx:11
 TMath.cxx:12
 TMath.cxx:13
 TMath.cxx:14
 TMath.cxx:15
 TMath.cxx:16
 TMath.cxx:17
 TMath.cxx:18
 TMath.cxx:19
 TMath.cxx:20
 TMath.cxx:21
 TMath.cxx:22
 TMath.cxx:23
 TMath.cxx:24
 TMath.cxx:25
 TMath.cxx:26
 TMath.cxx:27
 TMath.cxx:28
 TMath.cxx:29
 TMath.cxx:30
 TMath.cxx:31
 TMath.cxx:32
 TMath.cxx:33
 TMath.cxx:34
 TMath.cxx:35
 TMath.cxx:36
 TMath.cxx:37
 TMath.cxx:38
 TMath.cxx:39
 TMath.cxx:40
 TMath.cxx:41
 TMath.cxx:42
 TMath.cxx:43
 TMath.cxx:44
 TMath.cxx:45
 TMath.cxx:46
 TMath.cxx:47
 TMath.cxx:48
 TMath.cxx:49
 TMath.cxx:50
 TMath.cxx:51
 TMath.cxx:52
 TMath.cxx:53
 TMath.cxx:54
 TMath.cxx:55
 TMath.cxx:56
 TMath.cxx:57
 TMath.cxx:58
 TMath.cxx:59
 TMath.cxx:60
 TMath.cxx:61
 TMath.cxx:62
 TMath.cxx:63
 TMath.cxx:64
 TMath.cxx:65
 TMath.cxx:66
 TMath.cxx:67
 TMath.cxx:68
 TMath.cxx:69
 TMath.cxx:70
 TMath.cxx:71
 TMath.cxx:72
 TMath.cxx:73
 TMath.cxx:74
 TMath.cxx:75
 TMath.cxx:76
 TMath.cxx:77
 TMath.cxx:78
 TMath.cxx:79
 TMath.cxx:80
 TMath.cxx:81
 TMath.cxx:82
 TMath.cxx:83
 TMath.cxx:84
 TMath.cxx:85
 TMath.cxx:86
 TMath.cxx:87
 TMath.cxx:88
 TMath.cxx:89
 TMath.cxx:90
 TMath.cxx:91
 TMath.cxx:92
 TMath.cxx:93
 TMath.cxx:94
 TMath.cxx:95
 TMath.cxx:96
 TMath.cxx:97
 TMath.cxx:98
 TMath.cxx:99
 TMath.cxx:100
 TMath.cxx:101
 TMath.cxx:102
 TMath.cxx:103
 TMath.cxx:104
 TMath.cxx:105
 TMath.cxx:106
 TMath.cxx:107
 TMath.cxx:108
 TMath.cxx:109
 TMath.cxx:110
 TMath.cxx:111
 TMath.cxx:112
 TMath.cxx:113
 TMath.cxx:114
 TMath.cxx:115
 TMath.cxx:116
 TMath.cxx:117
 TMath.cxx:118
 TMath.cxx:119
 TMath.cxx:120
 TMath.cxx:121
 TMath.cxx:122
 TMath.cxx:123
 TMath.cxx:124
 TMath.cxx:125
 TMath.cxx:126
 TMath.cxx:127
 TMath.cxx:128
 TMath.cxx:129
 TMath.cxx:130
 TMath.cxx:131
 TMath.cxx:132
 TMath.cxx:133
 TMath.cxx:134
 TMath.cxx:135
 TMath.cxx:136
 TMath.cxx:137
 TMath.cxx:138
 TMath.cxx:139
 TMath.cxx:140
 TMath.cxx:141
 TMath.cxx:142
 TMath.cxx:143
 TMath.cxx:144
 TMath.cxx:145
 TMath.cxx:146
 TMath.cxx:147
 TMath.cxx:148
 TMath.cxx:149
 TMath.cxx:150
 TMath.cxx:151
 TMath.cxx:152
 TMath.cxx:153
 TMath.cxx:154
 TMath.cxx:155
 TMath.cxx:156
 TMath.cxx:157
 TMath.cxx:158
 TMath.cxx:159
 TMath.cxx:160
 TMath.cxx:161
 TMath.cxx:162
 TMath.cxx:163
 TMath.cxx:164
 TMath.cxx:165
 TMath.cxx:166
 TMath.cxx:167
 TMath.cxx:168
 TMath.cxx:169
 TMath.cxx:170
 TMath.cxx:171
 TMath.cxx:172
 TMath.cxx:173
 TMath.cxx:174
 TMath.cxx:175
 TMath.cxx:176
 TMath.cxx:177
 TMath.cxx:178
 TMath.cxx:179
 TMath.cxx:180
 TMath.cxx:181
 TMath.cxx:182
 TMath.cxx:183
 TMath.cxx:184
 TMath.cxx:185
 TMath.cxx:186
 TMath.cxx:187
 TMath.cxx:188
 TMath.cxx:189
 TMath.cxx:190
 TMath.cxx:191
 TMath.cxx:192
 TMath.cxx:193
 TMath.cxx:194
 TMath.cxx:195
 TMath.cxx:196
 TMath.cxx:197
 TMath.cxx:198
 TMath.cxx:199
 TMath.cxx:200
 TMath.cxx:201
 TMath.cxx:202
 TMath.cxx:203
 TMath.cxx:204
 TMath.cxx:205
 TMath.cxx:206
 TMath.cxx:207
 TMath.cxx:208
 TMath.cxx:209
 TMath.cxx:210
 TMath.cxx:211
 TMath.cxx:212
 TMath.cxx:213
 TMath.cxx:214
 TMath.cxx:215
 TMath.cxx:216
 TMath.cxx:217
 TMath.cxx:218
 TMath.cxx:219
 TMath.cxx:220
 TMath.cxx:221
 TMath.cxx:222
 TMath.cxx:223
 TMath.cxx:224
 TMath.cxx:225
 TMath.cxx:226
 TMath.cxx:227
 TMath.cxx:228
 TMath.cxx:229
 TMath.cxx:230
 TMath.cxx:231
 TMath.cxx:232
 TMath.cxx:233
 TMath.cxx:234
 TMath.cxx:235
 TMath.cxx:236
 TMath.cxx:237
 TMath.cxx:238
 TMath.cxx:239
 TMath.cxx:240
 TMath.cxx:241
 TMath.cxx:242
 TMath.cxx:243
 TMath.cxx:244
 TMath.cxx:245
 TMath.cxx:246
 TMath.cxx:247
 TMath.cxx:248
 TMath.cxx:249
 TMath.cxx:250
 TMath.cxx:251
 TMath.cxx:252
 TMath.cxx:253
 TMath.cxx:254
 TMath.cxx:255
 TMath.cxx:256
 TMath.cxx:257
 TMath.cxx:258
 TMath.cxx:259
 TMath.cxx:260
 TMath.cxx:261
 TMath.cxx:262
 TMath.cxx:263
 TMath.cxx:264
 TMath.cxx:265
 TMath.cxx:266
 TMath.cxx:267
 TMath.cxx:268
 TMath.cxx:269
 TMath.cxx:270
 TMath.cxx:271
 TMath.cxx:272
 TMath.cxx:273
 TMath.cxx:274
 TMath.cxx:275
 TMath.cxx:276
 TMath.cxx:277
 TMath.cxx:278
 TMath.cxx:279
 TMath.cxx:280
 TMath.cxx:281
 TMath.cxx:282
 TMath.cxx:283
 TMath.cxx:284
 TMath.cxx:285
 TMath.cxx:286
 TMath.cxx:287
 TMath.cxx:288
 TMath.cxx:289
 TMath.cxx:290
 TMath.cxx:291
 TMath.cxx:292
 TMath.cxx:293
 TMath.cxx:294
 TMath.cxx:295
 TMath.cxx:296
 TMath.cxx:297
 TMath.cxx:298
 TMath.cxx:299
 TMath.cxx:300
 TMath.cxx:301
 TMath.cxx:302
 TMath.cxx:303
 TMath.cxx:304
 TMath.cxx:305
 TMath.cxx:306
 TMath.cxx:307
 TMath.cxx:308
 TMath.cxx:309
 TMath.cxx:310
 TMath.cxx:311
 TMath.cxx:312
 TMath.cxx:313
 TMath.cxx:314
 TMath.cxx:315
 TMath.cxx:316
 TMath.cxx:317
 TMath.cxx:318
 TMath.cxx:319
 TMath.cxx:320
 TMath.cxx:321
 TMath.cxx:322
 TMath.cxx:323
 TMath.cxx:324
 TMath.cxx:325
 TMath.cxx:326
 TMath.cxx:327
 TMath.cxx:328
 TMath.cxx:329
 TMath.cxx:330
 TMath.cxx:331
 TMath.cxx:332
 TMath.cxx:333
 TMath.cxx:334
 TMath.cxx:335
 TMath.cxx:336
 TMath.cxx:337
 TMath.cxx:338
 TMath.cxx:339
 TMath.cxx:340
 TMath.cxx:341
 TMath.cxx:342
 TMath.cxx:343
 TMath.cxx:344
 TMath.cxx:345
 TMath.cxx:346
 TMath.cxx:347
 TMath.cxx:348
 TMath.cxx:349
 TMath.cxx:350
 TMath.cxx:351
 TMath.cxx:352
 TMath.cxx:353
 TMath.cxx:354
 TMath.cxx:355
 TMath.cxx:356
 TMath.cxx:357
 TMath.cxx:358
 TMath.cxx:359
 TMath.cxx:360
 TMath.cxx:361
 TMath.cxx:362
 TMath.cxx:363
 TMath.cxx:364
 TMath.cxx:365
 TMath.cxx:366
 TMath.cxx:367
 TMath.cxx:368
 TMath.cxx:369
 TMath.cxx:370
 TMath.cxx:371
 TMath.cxx:372
 TMath.cxx:373
 TMath.cxx:374
 TMath.cxx:375
 TMath.cxx:376
 TMath.cxx:377
 TMath.cxx:378
 TMath.cxx:379
 TMath.cxx:380
 TMath.cxx:381
 TMath.cxx:382
 TMath.cxx:383
 TMath.cxx:384
 TMath.cxx:385
 TMath.cxx:386
 TMath.cxx:387
 TMath.cxx:388
 TMath.cxx:389
 TMath.cxx:390
 TMath.cxx:391
 TMath.cxx:392
 TMath.cxx:393
 TMath.cxx:394
 TMath.cxx:395
 TMath.cxx:396
 TMath.cxx:397
 TMath.cxx:398
 TMath.cxx:399
 TMath.cxx:400
 TMath.cxx:401
 TMath.cxx:402
 TMath.cxx:403
 TMath.cxx:404
 TMath.cxx:405
 TMath.cxx:406
 TMath.cxx:407
 TMath.cxx:408
 TMath.cxx:409
 TMath.cxx:410
 TMath.cxx:411
 TMath.cxx:412
 TMath.cxx:413
 TMath.cxx:414
 TMath.cxx:415
 TMath.cxx:416
 TMath.cxx:417
 TMath.cxx:418
 TMath.cxx:419
 TMath.cxx:420
 TMath.cxx:421
 TMath.cxx:422
 TMath.cxx:423
 TMath.cxx:424
 TMath.cxx:425
 TMath.cxx:426
 TMath.cxx:427
 TMath.cxx:428
 TMath.cxx:429
 TMath.cxx:430
 TMath.cxx:431
 TMath.cxx:432
 TMath.cxx:433
 TMath.cxx:434
 TMath.cxx:435
 TMath.cxx:436
 TMath.cxx:437
 TMath.cxx:438
 TMath.cxx:439
 TMath.cxx:440
 TMath.cxx:441
 TMath.cxx:442
 TMath.cxx:443
 TMath.cxx:444
 TMath.cxx:445
 TMath.cxx:446
 TMath.cxx:447
 TMath.cxx:448
 TMath.cxx:449
 TMath.cxx:450
 TMath.cxx:451
 TMath.cxx:452
 TMath.cxx:453
 TMath.cxx:454
 TMath.cxx:455
 TMath.cxx:456
 TMath.cxx:457
 TMath.cxx:458
 TMath.cxx:459
 TMath.cxx:460
 TMath.cxx:461
 TMath.cxx:462
 TMath.cxx:463
 TMath.cxx:464
 TMath.cxx:465
 TMath.cxx:466
 TMath.cxx:467
 TMath.cxx:468
 TMath.cxx:469
 TMath.cxx:470
 TMath.cxx:471
 TMath.cxx:472
 TMath.cxx:473
 TMath.cxx:474
 TMath.cxx:475
 TMath.cxx:476
 TMath.cxx:477
 TMath.cxx:478
 TMath.cxx:479
 TMath.cxx:480
 TMath.cxx:481
 TMath.cxx:482
 TMath.cxx:483
 TMath.cxx:484
 TMath.cxx:485
 TMath.cxx:486
 TMath.cxx:487
 TMath.cxx:488
 TMath.cxx:489
 TMath.cxx:490
 TMath.cxx:491
 TMath.cxx:492
 TMath.cxx:493
 TMath.cxx:494
 TMath.cxx:495
 TMath.cxx:496
 TMath.cxx:497
 TMath.cxx:498
 TMath.cxx:499
 TMath.cxx:500
 TMath.cxx:501
 TMath.cxx:502
 TMath.cxx:503
 TMath.cxx:504
 TMath.cxx:505
 TMath.cxx:506
 TMath.cxx:507
 TMath.cxx:508
 TMath.cxx:509
 TMath.cxx:510
 TMath.cxx:511
 TMath.cxx:512
 TMath.cxx:513
 TMath.cxx:514
 TMath.cxx:515
 TMath.cxx:516
 TMath.cxx:517
 TMath.cxx:518
 TMath.cxx:519
 TMath.cxx:520
 TMath.cxx:521
 TMath.cxx:522
 TMath.cxx:523
 TMath.cxx:524
 TMath.cxx:525
 TMath.cxx:526
 TMath.cxx:527
 TMath.cxx:528
 TMath.cxx:529
 TMath.cxx:530
 TMath.cxx:531
 TMath.cxx:532
 TMath.cxx:533
 TMath.cxx:534
 TMath.cxx:535
 TMath.cxx:536
 TMath.cxx:537
 TMath.cxx:538
 TMath.cxx:539
 TMath.cxx:540
 TMath.cxx:541
 TMath.cxx:542
 TMath.cxx:543
 TMath.cxx:544
 TMath.cxx:545
 TMath.cxx:546
 TMath.cxx:547
 TMath.cxx:548
 TMath.cxx:549
 TMath.cxx:550
 TMath.cxx:551
 TMath.cxx:552
 TMath.cxx:553
 TMath.cxx:554
 TMath.cxx:555
 TMath.cxx:556
 TMath.cxx:557
 TMath.cxx:558
 TMath.cxx:559
 TMath.cxx:560
 TMath.cxx:561
 TMath.cxx:562
 TMath.cxx:563
 TMath.cxx:564
 TMath.cxx:565
 TMath.cxx:566
 TMath.cxx:567
 TMath.cxx:568
 TMath.cxx:569
 TMath.cxx:570
 TMath.cxx:571
 TMath.cxx:572
 TMath.cxx:573
 TMath.cxx:574
 TMath.cxx:575
 TMath.cxx:576
 TMath.cxx:577
 TMath.cxx:578
 TMath.cxx:579
 TMath.cxx:580
 TMath.cxx:581
 TMath.cxx:582
 TMath.cxx:583
 TMath.cxx:584
 TMath.cxx:585
 TMath.cxx:586
 TMath.cxx:587
 TMath.cxx:588
 TMath.cxx:589
 TMath.cxx:590
 TMath.cxx:591
 TMath.cxx:592
 TMath.cxx:593
 TMath.cxx:594
 TMath.cxx:595
 TMath.cxx:596
 TMath.cxx:597
 TMath.cxx:598
 TMath.cxx:599
 TMath.cxx:600
 TMath.cxx:601
 TMath.cxx:602
 TMath.cxx:603
 TMath.cxx:604
 TMath.cxx:605
 TMath.cxx:606
 TMath.cxx:607
 TMath.cxx:608
 TMath.cxx:609
 TMath.cxx:610
 TMath.cxx:611
 TMath.cxx:612
 TMath.cxx:613
 TMath.cxx:614
 TMath.cxx:615
 TMath.cxx:616
 TMath.cxx:617
 TMath.cxx:618
 TMath.cxx:619
 TMath.cxx:620
 TMath.cxx:621
 TMath.cxx:622
 TMath.cxx:623
 TMath.cxx:624
 TMath.cxx:625
 TMath.cxx:626
 TMath.cxx:627
 TMath.cxx:628
 TMath.cxx:629
 TMath.cxx:630
 TMath.cxx:631
 TMath.cxx:632
 TMath.cxx:633
 TMath.cxx:634
 TMath.cxx:635
 TMath.cxx:636
 TMath.cxx:637
 TMath.cxx:638
 TMath.cxx:639
 TMath.cxx:640
 TMath.cxx:641
 TMath.cxx:642
 TMath.cxx:643
 TMath.cxx:644
 TMath.cxx:645
 TMath.cxx:646
 TMath.cxx:647
 TMath.cxx:648
 TMath.cxx:649
 TMath.cxx:650
 TMath.cxx:651
 TMath.cxx:652
 TMath.cxx:653
 TMath.cxx:654
 TMath.cxx:655
 TMath.cxx:656
 TMath.cxx:657
 TMath.cxx:658
 TMath.cxx:659
 TMath.cxx:660
 TMath.cxx:661
 TMath.cxx:662
 TMath.cxx:663
 TMath.cxx:664
 TMath.cxx:665
 TMath.cxx:666
 TMath.cxx:667
 TMath.cxx:668
 TMath.cxx:669
 TMath.cxx:670
 TMath.cxx:671
 TMath.cxx:672
 TMath.cxx:673
 TMath.cxx:674
 TMath.cxx:675
 TMath.cxx:676
 TMath.cxx:677
 TMath.cxx:678
 TMath.cxx:679
 TMath.cxx:680
 TMath.cxx:681
 TMath.cxx:682
 TMath.cxx:683
 TMath.cxx:684
 TMath.cxx:685
 TMath.cxx:686
 TMath.cxx:687
 TMath.cxx:688
 TMath.cxx:689
 TMath.cxx:690
 TMath.cxx:691
 TMath.cxx:692
 TMath.cxx:693
 TMath.cxx:694
 TMath.cxx:695
 TMath.cxx:696
 TMath.cxx:697
 TMath.cxx:698
 TMath.cxx:699
 TMath.cxx:700
 TMath.cxx:701
 TMath.cxx:702
 TMath.cxx:703
 TMath.cxx:704
 TMath.cxx:705
 TMath.cxx:706
 TMath.cxx:707
 TMath.cxx:708
 TMath.cxx:709
 TMath.cxx:710
 TMath.cxx:711
 TMath.cxx:712
 TMath.cxx:713
 TMath.cxx:714
 TMath.cxx:715
 TMath.cxx:716
 TMath.cxx:717
 TMath.cxx:718
 TMath.cxx:719
 TMath.cxx:720
 TMath.cxx:721
 TMath.cxx:722
 TMath.cxx:723
 TMath.cxx:724
 TMath.cxx:725
 TMath.cxx:726
 TMath.cxx:727
 TMath.cxx:728
 TMath.cxx:729
 TMath.cxx:730
 TMath.cxx:731
 TMath.cxx:732
 TMath.cxx:733
 TMath.cxx:734
 TMath.cxx:735
 TMath.cxx:736
 TMath.cxx:737
 TMath.cxx:738
 TMath.cxx:739
 TMath.cxx:740
 TMath.cxx:741
 TMath.cxx:742
 TMath.cxx:743
 TMath.cxx:744
 TMath.cxx:745
 TMath.cxx:746
 TMath.cxx:747
 TMath.cxx:748
 TMath.cxx:749
 TMath.cxx:750
 TMath.cxx:751
 TMath.cxx:752
 TMath.cxx:753
 TMath.cxx:754
 TMath.cxx:755
 TMath.cxx:756
 TMath.cxx:757
 TMath.cxx:758
 TMath.cxx:759
 TMath.cxx:760
 TMath.cxx:761
 TMath.cxx:762
 TMath.cxx:763
 TMath.cxx:764
 TMath.cxx:765
 TMath.cxx:766
 TMath.cxx:767
 TMath.cxx:768
 TMath.cxx:769
 TMath.cxx:770
 TMath.cxx:771
 TMath.cxx:772
 TMath.cxx:773
 TMath.cxx:774
 TMath.cxx:775
 TMath.cxx:776
 TMath.cxx:777
 TMath.cxx:778
 TMath.cxx:779
 TMath.cxx:780
 TMath.cxx:781
 TMath.cxx:782
 TMath.cxx:783
 TMath.cxx:784
 TMath.cxx:785
 TMath.cxx:786
 TMath.cxx:787
 TMath.cxx:788
 TMath.cxx:789
 TMath.cxx:790
 TMath.cxx:791
 TMath.cxx:792
 TMath.cxx:793
 TMath.cxx:794
 TMath.cxx:795
 TMath.cxx:796
 TMath.cxx:797
 TMath.cxx:798
 TMath.cxx:799
 TMath.cxx:800
 TMath.cxx:801
 TMath.cxx:802
 TMath.cxx:803
 TMath.cxx:804
 TMath.cxx:805
 TMath.cxx:806
 TMath.cxx:807
 TMath.cxx:808
 TMath.cxx:809
 TMath.cxx:810
 TMath.cxx:811
 TMath.cxx:812
 TMath.cxx:813
 TMath.cxx:814
 TMath.cxx:815
 TMath.cxx:816
 TMath.cxx:817
 TMath.cxx:818
 TMath.cxx:819
 TMath.cxx:820
 TMath.cxx:821
 TMath.cxx:822
 TMath.cxx:823
 TMath.cxx:824
 TMath.cxx:825
 TMath.cxx:826
 TMath.cxx:827
 TMath.cxx:828
 TMath.cxx:829
 TMath.cxx:830
 TMath.cxx:831
 TMath.cxx:832
 TMath.cxx:833
 TMath.cxx:834
 TMath.cxx:835
 TMath.cxx:836
 TMath.cxx:837
 TMath.cxx:838
 TMath.cxx:839
 TMath.cxx:840
 TMath.cxx:841
 TMath.cxx:842
 TMath.cxx:843
 TMath.cxx:844
 TMath.cxx:845
 TMath.cxx:846
 TMath.cxx:847
 TMath.cxx:848
 TMath.cxx:849
 TMath.cxx:850
 TMath.cxx:851
 TMath.cxx:852
 TMath.cxx:853
 TMath.cxx:854
 TMath.cxx:855
 TMath.cxx:856
 TMath.cxx:857
 TMath.cxx:858
 TMath.cxx:859
 TMath.cxx:860
 TMath.cxx:861
 TMath.cxx:862
 TMath.cxx:863
 TMath.cxx:864
 TMath.cxx:865
 TMath.cxx:866
 TMath.cxx:867
 TMath.cxx:868
 TMath.cxx:869
 TMath.cxx:870
 TMath.cxx:871
 TMath.cxx:872
 TMath.cxx:873
 TMath.cxx:874
 TMath.cxx:875
 TMath.cxx:876
 TMath.cxx:877
 TMath.cxx:878
 TMath.cxx:879
 TMath.cxx:880
 TMath.cxx:881
 TMath.cxx:882
 TMath.cxx:883
 TMath.cxx:884
 TMath.cxx:885
 TMath.cxx:886
 TMath.cxx:887
 TMath.cxx:888
 TMath.cxx:889
 TMath.cxx:890
 TMath.cxx:891
 TMath.cxx:892
 TMath.cxx:893
 TMath.cxx:894
 TMath.cxx:895
 TMath.cxx:896
 TMath.cxx:897
 TMath.cxx:898
 TMath.cxx:899
 TMath.cxx:900
 TMath.cxx:901
 TMath.cxx:902
 TMath.cxx:903
 TMath.cxx:904
 TMath.cxx:905
 TMath.cxx:906
 TMath.cxx:907
 TMath.cxx:908
 TMath.cxx:909
 TMath.cxx:910
 TMath.cxx:911
 TMath.cxx:912
 TMath.cxx:913
 TMath.cxx:914
 TMath.cxx:915
 TMath.cxx:916
 TMath.cxx:917
 TMath.cxx:918
 TMath.cxx:919
 TMath.cxx:920
 TMath.cxx:921
 TMath.cxx:922
 TMath.cxx:923
 TMath.cxx:924
 TMath.cxx:925
 TMath.cxx:926
 TMath.cxx:927
 TMath.cxx:928
 TMath.cxx:929
 TMath.cxx:930
 TMath.cxx:931
 TMath.cxx:932
 TMath.cxx:933
 TMath.cxx:934
 TMath.cxx:935
 TMath.cxx:936
 TMath.cxx:937
 TMath.cxx:938
 TMath.cxx:939
 TMath.cxx:940
 TMath.cxx:941
 TMath.cxx:942
 TMath.cxx:943
 TMath.cxx:944
 TMath.cxx:945
 TMath.cxx:946
 TMath.cxx:947
 TMath.cxx:948
 TMath.cxx:949
 TMath.cxx:950
 TMath.cxx:951
 TMath.cxx:952
 TMath.cxx:953
 TMath.cxx:954
 TMath.cxx:955
 TMath.cxx:956
 TMath.cxx:957
 TMath.cxx:958
 TMath.cxx:959
 TMath.cxx:960
 TMath.cxx:961
 TMath.cxx:962
 TMath.cxx:963
 TMath.cxx:964
 TMath.cxx:965
 TMath.cxx:966
 TMath.cxx:967
 TMath.cxx:968
 TMath.cxx:969
 TMath.cxx:970
 TMath.cxx:971
 TMath.cxx:972
 TMath.cxx:973
 TMath.cxx:974
 TMath.cxx:975
 TMath.cxx:976
 TMath.cxx:977
 TMath.cxx:978
 TMath.cxx:979
 TMath.cxx:980
 TMath.cxx:981
 TMath.cxx:982
 TMath.cxx:983
 TMath.cxx:984
 TMath.cxx:985
 TMath.cxx:986
 TMath.cxx:987
 TMath.cxx:988
 TMath.cxx:989
 TMath.cxx:990
 TMath.cxx:991
 TMath.cxx:992
 TMath.cxx:993
 TMath.cxx:994
 TMath.cxx:995
 TMath.cxx:996
 TMath.cxx:997
 TMath.cxx:998
 TMath.cxx:999
 TMath.cxx:1000
 TMath.cxx:1001
 TMath.cxx:1002
 TMath.cxx:1003
 TMath.cxx:1004
 TMath.cxx:1005
 TMath.cxx:1006
 TMath.cxx:1007
 TMath.cxx:1008
 TMath.cxx:1009
 TMath.cxx:1010
 TMath.cxx:1011
 TMath.cxx:1012
 TMath.cxx:1013
 TMath.cxx:1014
 TMath.cxx:1015
 TMath.cxx:1016
 TMath.cxx:1017
 TMath.cxx:1018
 TMath.cxx:1019
 TMath.cxx:1020
 TMath.cxx:1021
 TMath.cxx:1022
 TMath.cxx:1023
 TMath.cxx:1024
 TMath.cxx:1025
 TMath.cxx:1026
 TMath.cxx:1027
 TMath.cxx:1028
 TMath.cxx:1029
 TMath.cxx:1030
 TMath.cxx:1031
 TMath.cxx:1032
 TMath.cxx:1033
 TMath.cxx:1034
 TMath.cxx:1035
 TMath.cxx:1036
 TMath.cxx:1037
 TMath.cxx:1038
 TMath.cxx:1039
 TMath.cxx:1040
 TMath.cxx:1041
 TMath.cxx:1042
 TMath.cxx:1043
 TMath.cxx:1044
 TMath.cxx:1045
 TMath.cxx:1046
 TMath.cxx:1047
 TMath.cxx:1048
 TMath.cxx:1049
 TMath.cxx:1050
 TMath.cxx:1051
 TMath.cxx:1052
 TMath.cxx:1053
 TMath.cxx:1054
 TMath.cxx:1055
 TMath.cxx:1056
 TMath.cxx:1057
 TMath.cxx:1058
 TMath.cxx:1059
 TMath.cxx:1060
 TMath.cxx:1061
 TMath.cxx:1062
 TMath.cxx:1063
 TMath.cxx:1064
 TMath.cxx:1065
 TMath.cxx:1066
 TMath.cxx:1067
 TMath.cxx:1068
 TMath.cxx:1069
 TMath.cxx:1070
 TMath.cxx:1071
 TMath.cxx:1072
 TMath.cxx:1073
 TMath.cxx:1074
 TMath.cxx:1075
 TMath.cxx:1076
 TMath.cxx:1077
 TMath.cxx:1078
 TMath.cxx:1079
 TMath.cxx:1080
 TMath.cxx:1081
 TMath.cxx:1082
 TMath.cxx:1083
 TMath.cxx:1084
 TMath.cxx:1085
 TMath.cxx:1086
 TMath.cxx:1087
 TMath.cxx:1088
 TMath.cxx:1089
 TMath.cxx:1090
 TMath.cxx:1091
 TMath.cxx:1092
 TMath.cxx:1093
 TMath.cxx:1094
 TMath.cxx:1095
 TMath.cxx:1096
 TMath.cxx:1097
 TMath.cxx:1098
 TMath.cxx:1099
 TMath.cxx:1100
 TMath.cxx:1101
 TMath.cxx:1102
 TMath.cxx:1103
 TMath.cxx:1104
 TMath.cxx:1105
 TMath.cxx:1106
 TMath.cxx:1107
 TMath.cxx:1108
 TMath.cxx:1109
 TMath.cxx:1110
 TMath.cxx:1111
 TMath.cxx:1112
 TMath.cxx:1113
 TMath.cxx:1114
 TMath.cxx:1115
 TMath.cxx:1116
 TMath.cxx:1117
 TMath.cxx:1118
 TMath.cxx:1119
 TMath.cxx:1120
 TMath.cxx:1121
 TMath.cxx:1122
 TMath.cxx:1123
 TMath.cxx:1124
 TMath.cxx:1125
 TMath.cxx:1126
 TMath.cxx:1127
 TMath.cxx:1128
 TMath.cxx:1129
 TMath.cxx:1130
 TMath.cxx:1131
 TMath.cxx:1132
 TMath.cxx:1133
 TMath.cxx:1134
 TMath.cxx:1135
 TMath.cxx:1136
 TMath.cxx:1137
 TMath.cxx:1138
 TMath.cxx:1139
 TMath.cxx:1140
 TMath.cxx:1141
 TMath.cxx:1142
 TMath.cxx:1143
 TMath.cxx:1144
 TMath.cxx:1145
 TMath.cxx:1146
 TMath.cxx:1147
 TMath.cxx:1148
 TMath.cxx:1149
 TMath.cxx:1150
 TMath.cxx:1151
 TMath.cxx:1152
 TMath.cxx:1153
 TMath.cxx:1154
 TMath.cxx:1155
 TMath.cxx:1156
 TMath.cxx:1157
 TMath.cxx:1158
 TMath.cxx:1159
 TMath.cxx:1160
 TMath.cxx:1161
 TMath.cxx:1162
 TMath.cxx:1163
 TMath.cxx:1164
 TMath.cxx:1165
 TMath.cxx:1166
 TMath.cxx:1167
 TMath.cxx:1168
 TMath.cxx:1169
 TMath.cxx:1170
 TMath.cxx:1171
 TMath.cxx:1172
 TMath.cxx:1173
 TMath.cxx:1174
 TMath.cxx:1175
 TMath.cxx:1176
 TMath.cxx:1177
 TMath.cxx:1178
 TMath.cxx:1179
 TMath.cxx:1180
 TMath.cxx:1181
 TMath.cxx:1182
 TMath.cxx:1183
 TMath.cxx:1184
 TMath.cxx:1185
 TMath.cxx:1186
 TMath.cxx:1187
 TMath.cxx:1188
 TMath.cxx:1189
 TMath.cxx:1190
 TMath.cxx:1191
 TMath.cxx:1192
 TMath.cxx:1193
 TMath.cxx:1194
 TMath.cxx:1195
 TMath.cxx:1196
 TMath.cxx:1197
 TMath.cxx:1198
 TMath.cxx:1199
 TMath.cxx:1200
 TMath.cxx:1201
 TMath.cxx:1202
 TMath.cxx:1203
 TMath.cxx:1204
 TMath.cxx:1205
 TMath.cxx:1206
 TMath.cxx:1207
 TMath.cxx:1208
 TMath.cxx:1209
 TMath.cxx:1210
 TMath.cxx:1211
 TMath.cxx:1212
 TMath.cxx:1213
 TMath.cxx:1214
 TMath.cxx:1215
 TMath.cxx:1216
 TMath.cxx:1217
 TMath.cxx:1218
 TMath.cxx:1219
 TMath.cxx:1220
 TMath.cxx:1221
 TMath.cxx:1222
 TMath.cxx:1223
 TMath.cxx:1224
 TMath.cxx:1225
 TMath.cxx:1226
 TMath.cxx:1227
 TMath.cxx:1228
 TMath.cxx:1229
 TMath.cxx:1230
 TMath.cxx:1231
 TMath.cxx:1232
 TMath.cxx:1233
 TMath.cxx:1234
 TMath.cxx:1235
 TMath.cxx:1236
 TMath.cxx:1237
 TMath.cxx:1238
 TMath.cxx:1239
 TMath.cxx:1240
 TMath.cxx:1241
 TMath.cxx:1242
 TMath.cxx:1243
 TMath.cxx:1244
 TMath.cxx:1245
 TMath.cxx:1246
 TMath.cxx:1247
 TMath.cxx:1248
 TMath.cxx:1249
 TMath.cxx:1250
 TMath.cxx:1251
 TMath.cxx:1252
 TMath.cxx:1253
 TMath.cxx:1254
 TMath.cxx:1255
 TMath.cxx:1256
 TMath.cxx:1257
 TMath.cxx:1258
 TMath.cxx:1259
 TMath.cxx:1260
 TMath.cxx:1261
 TMath.cxx:1262
 TMath.cxx:1263
 TMath.cxx:1264
 TMath.cxx:1265
 TMath.cxx:1266
 TMath.cxx:1267
 TMath.cxx:1268
 TMath.cxx:1269
 TMath.cxx:1270
 TMath.cxx:1271
 TMath.cxx:1272
 TMath.cxx:1273
 TMath.cxx:1274
 TMath.cxx:1275
 TMath.cxx:1276
 TMath.cxx:1277
 TMath.cxx:1278
 TMath.cxx:1279
 TMath.cxx:1280
 TMath.cxx:1281
 TMath.cxx:1282
 TMath.cxx:1283
 TMath.cxx:1284
 TMath.cxx:1285
 TMath.cxx:1286
 TMath.cxx:1287
 TMath.cxx:1288
 TMath.cxx:1289
 TMath.cxx:1290
 TMath.cxx:1291
 TMath.cxx:1292
 TMath.cxx:1293
 TMath.cxx:1294
 TMath.cxx:1295
 TMath.cxx:1296
 TMath.cxx:1297
 TMath.cxx:1298
 TMath.cxx:1299
 TMath.cxx:1300
 TMath.cxx:1301
 TMath.cxx:1302
 TMath.cxx:1303
 TMath.cxx:1304
 TMath.cxx:1305
 TMath.cxx:1306
 TMath.cxx:1307
 TMath.cxx:1308
 TMath.cxx:1309
 TMath.cxx:1310
 TMath.cxx:1311
 TMath.cxx:1312
 TMath.cxx:1313
 TMath.cxx:1314
 TMath.cxx:1315
 TMath.cxx:1316
 TMath.cxx:1317
 TMath.cxx:1318
 TMath.cxx:1319
 TMath.cxx:1320
 TMath.cxx:1321
 TMath.cxx:1322
 TMath.cxx:1323
 TMath.cxx:1324
 TMath.cxx:1325
 TMath.cxx:1326
 TMath.cxx:1327
 TMath.cxx:1328
 TMath.cxx:1329
 TMath.cxx:1330
 TMath.cxx:1331
 TMath.cxx:1332
 TMath.cxx:1333
 TMath.cxx:1334
 TMath.cxx:1335
 TMath.cxx:1336
 TMath.cxx:1337
 TMath.cxx:1338
 TMath.cxx:1339
 TMath.cxx:1340
 TMath.cxx:1341
 TMath.cxx:1342
 TMath.cxx:1343
 TMath.cxx:1344
 TMath.cxx:1345
 TMath.cxx:1346
 TMath.cxx:1347
 TMath.cxx:1348
 TMath.cxx:1349
 TMath.cxx:1350
 TMath.cxx:1351
 TMath.cxx:1352
 TMath.cxx:1353
 TMath.cxx:1354
 TMath.cxx:1355
 TMath.cxx:1356
 TMath.cxx:1357
 TMath.cxx:1358
 TMath.cxx:1359
 TMath.cxx:1360
 TMath.cxx:1361
 TMath.cxx:1362
 TMath.cxx:1363
 TMath.cxx:1364
 TMath.cxx:1365
 TMath.cxx:1366
 TMath.cxx:1367
 TMath.cxx:1368
 TMath.cxx:1369
 TMath.cxx:1370
 TMath.cxx:1371
 TMath.cxx:1372
 TMath.cxx:1373
 TMath.cxx:1374
 TMath.cxx:1375
 TMath.cxx:1376
 TMath.cxx:1377
 TMath.cxx:1378
 TMath.cxx:1379
 TMath.cxx:1380
 TMath.cxx:1381
 TMath.cxx:1382
 TMath.cxx:1383
 TMath.cxx:1384
 TMath.cxx:1385
 TMath.cxx:1386
 TMath.cxx:1387
 TMath.cxx:1388
 TMath.cxx:1389
 TMath.cxx:1390
 TMath.cxx:1391
 TMath.cxx:1392
 TMath.cxx:1393
 TMath.cxx:1394
 TMath.cxx:1395
 TMath.cxx:1396
 TMath.cxx:1397
 TMath.cxx:1398
 TMath.cxx:1399
 TMath.cxx:1400
 TMath.cxx:1401
 TMath.cxx:1402
 TMath.cxx:1403
 TMath.cxx:1404
 TMath.cxx:1405
 TMath.cxx:1406
 TMath.cxx:1407
 TMath.cxx:1408
 TMath.cxx:1409
 TMath.cxx:1410
 TMath.cxx:1411
 TMath.cxx:1412
 TMath.cxx:1413
 TMath.cxx:1414
 TMath.cxx:1415
 TMath.cxx:1416
 TMath.cxx:1417
 TMath.cxx:1418
 TMath.cxx:1419
 TMath.cxx:1420
 TMath.cxx:1421
 TMath.cxx:1422
 TMath.cxx:1423
 TMath.cxx:1424
 TMath.cxx:1425
 TMath.cxx:1426
 TMath.cxx:1427
 TMath.cxx:1428
 TMath.cxx:1429
 TMath.cxx:1430
 TMath.cxx:1431
 TMath.cxx:1432
 TMath.cxx:1433
 TMath.cxx:1434
 TMath.cxx:1435
 TMath.cxx:1436
 TMath.cxx:1437
 TMath.cxx:1438
 TMath.cxx:1439
 TMath.cxx:1440
 TMath.cxx:1441
 TMath.cxx:1442
 TMath.cxx:1443
 TMath.cxx:1444
 TMath.cxx:1445
 TMath.cxx:1446
 TMath.cxx:1447
 TMath.cxx:1448
 TMath.cxx:1449
 TMath.cxx:1450
 TMath.cxx:1451
 TMath.cxx:1452
 TMath.cxx:1453
 TMath.cxx:1454
 TMath.cxx:1455
 TMath.cxx:1456
 TMath.cxx:1457
 TMath.cxx:1458
 TMath.cxx:1459
 TMath.cxx:1460
 TMath.cxx:1461
 TMath.cxx:1462
 TMath.cxx:1463
 TMath.cxx:1464
 TMath.cxx:1465
 TMath.cxx:1466
 TMath.cxx:1467
 TMath.cxx:1468
 TMath.cxx:1469
 TMath.cxx:1470
 TMath.cxx:1471
 TMath.cxx:1472
 TMath.cxx:1473
 TMath.cxx:1474
 TMath.cxx:1475
 TMath.cxx:1476
 TMath.cxx:1477
 TMath.cxx:1478
 TMath.cxx:1479
 TMath.cxx:1480
 TMath.cxx:1481
 TMath.cxx:1482
 TMath.cxx:1483
 TMath.cxx:1484
 TMath.cxx:1485
 TMath.cxx:1486
 TMath.cxx:1487
 TMath.cxx:1488
 TMath.cxx:1489
 TMath.cxx:1490
 TMath.cxx:1491
 TMath.cxx:1492
 TMath.cxx:1493
 TMath.cxx:1494
 TMath.cxx:1495
 TMath.cxx:1496
 TMath.cxx:1497
 TMath.cxx:1498
 TMath.cxx:1499
 TMath.cxx:1500
 TMath.cxx:1501
 TMath.cxx:1502
 TMath.cxx:1503
 TMath.cxx:1504
 TMath.cxx:1505
 TMath.cxx:1506
 TMath.cxx:1507
 TMath.cxx:1508
 TMath.cxx:1509
 TMath.cxx:1510
 TMath.cxx:1511
 TMath.cxx:1512
 TMath.cxx:1513
 TMath.cxx:1514
 TMath.cxx:1515
 TMath.cxx:1516
 TMath.cxx:1517
 TMath.cxx:1518
 TMath.cxx:1519
 TMath.cxx:1520
 TMath.cxx:1521
 TMath.cxx:1522
 TMath.cxx:1523
 TMath.cxx:1524
 TMath.cxx:1525
 TMath.cxx:1526
 TMath.cxx:1527
 TMath.cxx:1528
 TMath.cxx:1529
 TMath.cxx:1530
 TMath.cxx:1531
 TMath.cxx:1532
 TMath.cxx:1533
 TMath.cxx:1534
 TMath.cxx:1535
 TMath.cxx:1536
 TMath.cxx:1537
 TMath.cxx:1538
 TMath.cxx:1539
 TMath.cxx:1540
 TMath.cxx:1541
 TMath.cxx:1542
 TMath.cxx:1543
 TMath.cxx:1544
 TMath.cxx:1545
 TMath.cxx:1546
 TMath.cxx:1547
 TMath.cxx:1548
 TMath.cxx:1549
 TMath.cxx:1550
 TMath.cxx:1551
 TMath.cxx:1552
 TMath.cxx:1553
 TMath.cxx:1554
 TMath.cxx:1555
 TMath.cxx:1556
 TMath.cxx:1557
 TMath.cxx:1558
 TMath.cxx:1559
 TMath.cxx:1560
 TMath.cxx:1561
 TMath.cxx:1562
 TMath.cxx:1563
 TMath.cxx:1564
 TMath.cxx:1565
 TMath.cxx:1566
 TMath.cxx:1567
 TMath.cxx:1568
 TMath.cxx:1569
 TMath.cxx:1570
 TMath.cxx:1571
 TMath.cxx:1572
 TMath.cxx:1573
 TMath.cxx:1574
 TMath.cxx:1575
 TMath.cxx:1576
 TMath.cxx:1577
 TMath.cxx:1578
 TMath.cxx:1579
 TMath.cxx:1580
 TMath.cxx:1581
 TMath.cxx:1582
 TMath.cxx:1583
 TMath.cxx:1584
 TMath.cxx:1585
 TMath.cxx:1586
 TMath.cxx:1587
 TMath.cxx:1588
 TMath.cxx:1589
 TMath.cxx:1590
 TMath.cxx:1591
 TMath.cxx:1592
 TMath.cxx:1593
 TMath.cxx:1594
 TMath.cxx:1595
 TMath.cxx:1596
 TMath.cxx:1597
 TMath.cxx:1598
 TMath.cxx:1599
 TMath.cxx:1600
 TMath.cxx:1601
 TMath.cxx:1602
 TMath.cxx:1603
 TMath.cxx:1604
 TMath.cxx:1605
 TMath.cxx:1606
 TMath.cxx:1607
 TMath.cxx:1608
 TMath.cxx:1609
 TMath.cxx:1610
 TMath.cxx:1611
 TMath.cxx:1612
 TMath.cxx:1613
 TMath.cxx:1614
 TMath.cxx:1615
 TMath.cxx:1616
 TMath.cxx:1617
 TMath.cxx:1618
 TMath.cxx:1619
 TMath.cxx:1620
 TMath.cxx:1621
 TMath.cxx:1622
 TMath.cxx:1623
 TMath.cxx:1624
 TMath.cxx:1625
 TMath.cxx:1626
 TMath.cxx:1627
 TMath.cxx:1628
 TMath.cxx:1629
 TMath.cxx:1630
 TMath.cxx:1631
 TMath.cxx:1632
 TMath.cxx:1633
 TMath.cxx:1634
 TMath.cxx:1635
 TMath.cxx:1636
 TMath.cxx:1637
 TMath.cxx:1638
 TMath.cxx:1639
 TMath.cxx:1640
 TMath.cxx:1641
 TMath.cxx:1642
 TMath.cxx:1643
 TMath.cxx:1644
 TMath.cxx:1645
 TMath.cxx:1646
 TMath.cxx:1647
 TMath.cxx:1648
 TMath.cxx:1649
 TMath.cxx:1650
 TMath.cxx:1651
 TMath.cxx:1652
 TMath.cxx:1653
 TMath.cxx:1654
 TMath.cxx:1655
 TMath.cxx:1656
 TMath.cxx:1657
 TMath.cxx:1658
 TMath.cxx:1659
 TMath.cxx:1660
 TMath.cxx:1661
 TMath.cxx:1662
 TMath.cxx:1663
 TMath.cxx:1664
 TMath.cxx:1665
 TMath.cxx:1666
 TMath.cxx:1667
 TMath.cxx:1668
 TMath.cxx:1669
 TMath.cxx:1670
 TMath.cxx:1671
 TMath.cxx:1672
 TMath.cxx:1673
 TMath.cxx:1674
 TMath.cxx:1675
 TMath.cxx:1676
 TMath.cxx:1677
 TMath.cxx:1678
 TMath.cxx:1679
 TMath.cxx:1680
 TMath.cxx:1681
 TMath.cxx:1682
 TMath.cxx:1683
 TMath.cxx:1684
 TMath.cxx:1685
 TMath.cxx:1686
 TMath.cxx:1687
 TMath.cxx:1688
 TMath.cxx:1689
 TMath.cxx:1690
 TMath.cxx:1691
 TMath.cxx:1692
 TMath.cxx:1693
 TMath.cxx:1694
 TMath.cxx:1695
 TMath.cxx:1696
 TMath.cxx:1697
 TMath.cxx:1698
 TMath.cxx:1699
 TMath.cxx:1700
 TMath.cxx:1701
 TMath.cxx:1702
 TMath.cxx:1703
 TMath.cxx:1704
 TMath.cxx:1705
 TMath.cxx:1706
 TMath.cxx:1707
 TMath.cxx:1708
 TMath.cxx:1709
 TMath.cxx:1710
 TMath.cxx:1711
 TMath.cxx:1712
 TMath.cxx:1713
 TMath.cxx:1714
 TMath.cxx:1715
 TMath.cxx:1716
 TMath.cxx:1717
 TMath.cxx:1718
 TMath.cxx:1719
 TMath.cxx:1720
 TMath.cxx:1721
 TMath.cxx:1722
 TMath.cxx:1723
 TMath.cxx:1724
 TMath.cxx:1725
 TMath.cxx:1726
 TMath.cxx:1727
 TMath.cxx:1728
 TMath.cxx:1729
 TMath.cxx:1730
 TMath.cxx:1731
 TMath.cxx:1732
 TMath.cxx:1733
 TMath.cxx:1734
 TMath.cxx:1735
 TMath.cxx:1736
 TMath.cxx:1737
 TMath.cxx:1738
 TMath.cxx:1739
 TMath.cxx:1740
 TMath.cxx:1741
 TMath.cxx:1742
 TMath.cxx:1743
 TMath.cxx:1744
 TMath.cxx:1745
 TMath.cxx:1746
 TMath.cxx:1747
 TMath.cxx:1748
 TMath.cxx:1749
 TMath.cxx:1750
 TMath.cxx:1751
 TMath.cxx:1752
 TMath.cxx:1753
 TMath.cxx:1754
 TMath.cxx:1755
 TMath.cxx:1756
 TMath.cxx:1757
 TMath.cxx:1758
 TMath.cxx:1759
 TMath.cxx:1760
 TMath.cxx:1761
 TMath.cxx:1762
 TMath.cxx:1763
 TMath.cxx:1764
 TMath.cxx:1765
 TMath.cxx:1766
 TMath.cxx:1767
 TMath.cxx:1768
 TMath.cxx:1769
 TMath.cxx:1770
 TMath.cxx:1771
 TMath.cxx:1772
 TMath.cxx:1773
 TMath.cxx:1774
 TMath.cxx:1775
 TMath.cxx:1776
 TMath.cxx:1777
 TMath.cxx:1778
 TMath.cxx:1779
 TMath.cxx:1780
 TMath.cxx:1781
 TMath.cxx:1782
 TMath.cxx:1783
 TMath.cxx:1784
 TMath.cxx:1785
 TMath.cxx:1786
 TMath.cxx:1787
 TMath.cxx:1788
 TMath.cxx:1789
 TMath.cxx:1790
 TMath.cxx:1791
 TMath.cxx:1792
 TMath.cxx:1793
 TMath.cxx:1794
 TMath.cxx:1795
 TMath.cxx:1796
 TMath.cxx:1797
 TMath.cxx:1798
 TMath.cxx:1799
 TMath.cxx:1800
 TMath.cxx:1801
 TMath.cxx:1802
 TMath.cxx:1803
 TMath.cxx:1804
 TMath.cxx:1805
 TMath.cxx:1806
 TMath.cxx:1807
 TMath.cxx:1808
 TMath.cxx:1809
 TMath.cxx:1810
 TMath.cxx:1811
 TMath.cxx:1812
 TMath.cxx:1813
 TMath.cxx:1814
 TMath.cxx:1815
 TMath.cxx:1816
 TMath.cxx:1817
 TMath.cxx:1818
 TMath.cxx:1819
 TMath.cxx:1820
 TMath.cxx:1821
 TMath.cxx:1822
 TMath.cxx:1823
 TMath.cxx:1824
 TMath.cxx:1825
 TMath.cxx:1826
 TMath.cxx:1827
 TMath.cxx:1828
 TMath.cxx:1829
 TMath.cxx:1830
 TMath.cxx:1831
 TMath.cxx:1832
 TMath.cxx:1833
 TMath.cxx:1834
 TMath.cxx:1835
 TMath.cxx:1836
 TMath.cxx:1837
 TMath.cxx:1838
 TMath.cxx:1839
 TMath.cxx:1840
 TMath.cxx:1841
 TMath.cxx:1842
 TMath.cxx:1843
 TMath.cxx:1844
 TMath.cxx:1845
 TMath.cxx:1846
 TMath.cxx:1847
 TMath.cxx:1848
 TMath.cxx:1849
 TMath.cxx:1850
 TMath.cxx:1851
 TMath.cxx:1852
 TMath.cxx:1853
 TMath.cxx:1854
 TMath.cxx:1855
 TMath.cxx:1856
 TMath.cxx:1857
 TMath.cxx:1858
 TMath.cxx:1859
 TMath.cxx:1860
 TMath.cxx:1861
 TMath.cxx:1862
 TMath.cxx:1863
 TMath.cxx:1864
 TMath.cxx:1865
 TMath.cxx:1866
 TMath.cxx:1867
 TMath.cxx:1868
 TMath.cxx:1869
 TMath.cxx:1870
 TMath.cxx:1871
 TMath.cxx:1872
 TMath.cxx:1873
 TMath.cxx:1874
 TMath.cxx:1875
 TMath.cxx:1876
 TMath.cxx:1877
 TMath.cxx:1878
 TMath.cxx:1879
 TMath.cxx:1880
 TMath.cxx:1881
 TMath.cxx:1882
 TMath.cxx:1883
 TMath.cxx:1884
 TMath.cxx:1885
 TMath.cxx:1886
 TMath.cxx:1887
 TMath.cxx:1888
 TMath.cxx:1889
 TMath.cxx:1890
 TMath.cxx:1891
 TMath.cxx:1892
 TMath.cxx:1893
 TMath.cxx:1894
 TMath.cxx:1895
 TMath.cxx:1896
 TMath.cxx:1897
 TMath.cxx:1898
 TMath.cxx:1899
 TMath.cxx:1900
 TMath.cxx:1901
 TMath.cxx:1902
 TMath.cxx:1903
 TMath.cxx:1904
 TMath.cxx:1905
 TMath.cxx:1906
 TMath.cxx:1907
 TMath.cxx:1908
 TMath.cxx:1909
 TMath.cxx:1910
 TMath.cxx:1911
 TMath.cxx:1912
 TMath.cxx:1913
 TMath.cxx:1914
 TMath.cxx:1915
 TMath.cxx:1916
 TMath.cxx:1917
 TMath.cxx:1918
 TMath.cxx:1919
 TMath.cxx:1920
 TMath.cxx:1921
 TMath.cxx:1922
 TMath.cxx:1923
 TMath.cxx:1924
 TMath.cxx:1925
 TMath.cxx:1926
 TMath.cxx:1927
 TMath.cxx:1928
 TMath.cxx:1929
 TMath.cxx:1930
 TMath.cxx:1931
 TMath.cxx:1932
 TMath.cxx:1933
 TMath.cxx:1934
 TMath.cxx:1935
 TMath.cxx:1936
 TMath.cxx:1937
 TMath.cxx:1938
 TMath.cxx:1939
 TMath.cxx:1940
 TMath.cxx:1941
 TMath.cxx:1942
 TMath.cxx:1943
 TMath.cxx:1944
 TMath.cxx:1945
 TMath.cxx:1946
 TMath.cxx:1947
 TMath.cxx:1948
 TMath.cxx:1949
 TMath.cxx:1950
 TMath.cxx:1951
 TMath.cxx:1952
 TMath.cxx:1953
 TMath.cxx:1954
 TMath.cxx:1955
 TMath.cxx:1956
 TMath.cxx:1957
 TMath.cxx:1958
 TMath.cxx:1959
 TMath.cxx:1960
 TMath.cxx:1961
 TMath.cxx:1962
 TMath.cxx:1963
 TMath.cxx:1964
 TMath.cxx:1965
 TMath.cxx:1966
 TMath.cxx:1967
 TMath.cxx:1968
 TMath.cxx:1969
 TMath.cxx:1970
 TMath.cxx:1971
 TMath.cxx:1972
 TMath.cxx:1973
 TMath.cxx:1974
 TMath.cxx:1975
 TMath.cxx:1976
 TMath.cxx:1977
 TMath.cxx:1978
 TMath.cxx:1979
 TMath.cxx:1980
 TMath.cxx:1981
 TMath.cxx:1982
 TMath.cxx:1983
 TMath.cxx:1984
 TMath.cxx:1985
 TMath.cxx:1986
 TMath.cxx:1987
 TMath.cxx:1988
 TMath.cxx:1989
 TMath.cxx:1990
 TMath.cxx:1991
 TMath.cxx:1992
 TMath.cxx:1993
 TMath.cxx:1994
 TMath.cxx:1995
 TMath.cxx:1996
 TMath.cxx:1997
 TMath.cxx:1998
 TMath.cxx:1999
 TMath.cxx:2000
 TMath.cxx:2001
 TMath.cxx:2002
 TMath.cxx:2003
 TMath.cxx:2004
 TMath.cxx:2005
 TMath.cxx:2006
 TMath.cxx:2007
 TMath.cxx:2008
 TMath.cxx:2009
 TMath.cxx:2010
 TMath.cxx:2011
 TMath.cxx:2012
 TMath.cxx:2013
 TMath.cxx:2014
 TMath.cxx:2015
 TMath.cxx:2016
 TMath.cxx:2017
 TMath.cxx:2018
 TMath.cxx:2019
 TMath.cxx:2020
 TMath.cxx:2021
 TMath.cxx:2022
 TMath.cxx:2023
 TMath.cxx:2024
 TMath.cxx:2025
 TMath.cxx:2026
 TMath.cxx:2027
 TMath.cxx:2028
 TMath.cxx:2029
 TMath.cxx:2030
 TMath.cxx:2031
 TMath.cxx:2032
 TMath.cxx:2033
 TMath.cxx:2034
 TMath.cxx:2035
 TMath.cxx:2036
 TMath.cxx:2037
 TMath.cxx:2038
 TMath.cxx:2039
 TMath.cxx:2040
 TMath.cxx:2041
 TMath.cxx:2042
 TMath.cxx:2043
 TMath.cxx:2044
 TMath.cxx:2045
 TMath.cxx:2046
 TMath.cxx:2047
 TMath.cxx:2048
 TMath.cxx:2049
 TMath.cxx:2050
 TMath.cxx:2051
 TMath.cxx:2052
 TMath.cxx:2053
 TMath.cxx:2054
 TMath.cxx:2055
 TMath.cxx:2056
 TMath.cxx:2057
 TMath.cxx:2058
 TMath.cxx:2059
 TMath.cxx:2060
 TMath.cxx:2061
 TMath.cxx:2062
 TMath.cxx:2063
 TMath.cxx:2064
 TMath.cxx:2065
 TMath.cxx:2066
 TMath.cxx:2067
 TMath.cxx:2068
 TMath.cxx:2069
 TMath.cxx:2070
 TMath.cxx:2071
 TMath.cxx:2072
 TMath.cxx:2073
 TMath.cxx:2074
 TMath.cxx:2075
 TMath.cxx:2076
 TMath.cxx:2077
 TMath.cxx:2078
 TMath.cxx:2079
 TMath.cxx:2080
 TMath.cxx:2081
 TMath.cxx:2082
 TMath.cxx:2083
 TMath.cxx:2084
 TMath.cxx:2085
 TMath.cxx:2086
 TMath.cxx:2087
 TMath.cxx:2088
 TMath.cxx:2089
 TMath.cxx:2090
 TMath.cxx:2091
 TMath.cxx:2092
 TMath.cxx:2093
 TMath.cxx:2094
 TMath.cxx:2095
 TMath.cxx:2096
 TMath.cxx:2097
 TMath.cxx:2098
 TMath.cxx:2099
 TMath.cxx:2100
 TMath.cxx:2101
 TMath.cxx:2102
 TMath.cxx:2103
 TMath.cxx:2104
 TMath.cxx:2105
 TMath.cxx:2106
 TMath.cxx:2107
 TMath.cxx:2108
 TMath.cxx:2109
 TMath.cxx:2110
 TMath.cxx:2111
 TMath.cxx:2112
 TMath.cxx:2113
 TMath.cxx:2114
 TMath.cxx:2115
 TMath.cxx:2116
 TMath.cxx:2117
 TMath.cxx:2118
 TMath.cxx:2119
 TMath.cxx:2120
 TMath.cxx:2121
 TMath.cxx:2122
 TMath.cxx:2123
 TMath.cxx:2124
 TMath.cxx:2125
 TMath.cxx:2126
 TMath.cxx:2127
 TMath.cxx:2128
 TMath.cxx:2129
 TMath.cxx:2130
 TMath.cxx:2131
 TMath.cxx:2132
 TMath.cxx:2133
 TMath.cxx:2134
 TMath.cxx:2135
 TMath.cxx:2136
 TMath.cxx:2137
 TMath.cxx:2138
 TMath.cxx:2139
 TMath.cxx:2140
 TMath.cxx:2141
 TMath.cxx:2142
 TMath.cxx:2143
 TMath.cxx:2144
 TMath.cxx:2145
 TMath.cxx:2146
 TMath.cxx:2147
 TMath.cxx:2148
 TMath.cxx:2149
 TMath.cxx:2150
 TMath.cxx:2151
 TMath.cxx:2152
 TMath.cxx:2153
 TMath.cxx:2154
 TMath.cxx:2155
 TMath.cxx:2156
 TMath.cxx:2157
 TMath.cxx:2158
 TMath.cxx:2159
 TMath.cxx:2160
 TMath.cxx:2161
 TMath.cxx:2162
 TMath.cxx:2163
 TMath.cxx:2164
 TMath.cxx:2165
 TMath.cxx:2166
 TMath.cxx:2167
 TMath.cxx:2168
 TMath.cxx:2169
 TMath.cxx:2170
 TMath.cxx:2171
 TMath.cxx:2172
 TMath.cxx:2173
 TMath.cxx:2174
 TMath.cxx:2175
 TMath.cxx:2176
 TMath.cxx:2177
 TMath.cxx:2178
 TMath.cxx:2179
 TMath.cxx:2180
 TMath.cxx:2181
 TMath.cxx:2182
 TMath.cxx:2183
 TMath.cxx:2184
 TMath.cxx:2185
 TMath.cxx:2186
 TMath.cxx:2187
 TMath.cxx:2188
 TMath.cxx:2189
 TMath.cxx:2190
 TMath.cxx:2191
 TMath.cxx:2192
 TMath.cxx:2193
 TMath.cxx:2194
 TMath.cxx:2195
 TMath.cxx:2196
 TMath.cxx:2197
 TMath.cxx:2198
 TMath.cxx:2199
 TMath.cxx:2200
 TMath.cxx:2201
 TMath.cxx:2202
 TMath.cxx:2203
 TMath.cxx:2204
 TMath.cxx:2205
 TMath.cxx:2206
 TMath.cxx:2207
 TMath.cxx:2208
 TMath.cxx:2209
 TMath.cxx:2210
 TMath.cxx:2211
 TMath.cxx:2212
 TMath.cxx:2213
 TMath.cxx:2214
 TMath.cxx:2215
 TMath.cxx:2216
 TMath.cxx:2217
 TMath.cxx:2218
 TMath.cxx:2219
 TMath.cxx:2220
 TMath.cxx:2221
 TMath.cxx:2222
 TMath.cxx:2223
 TMath.cxx:2224
 TMath.cxx:2225
 TMath.cxx:2226
 TMath.cxx:2227
 TMath.cxx:2228
 TMath.cxx:2229
 TMath.cxx:2230
 TMath.cxx:2231
 TMath.cxx:2232
 TMath.cxx:2233
 TMath.cxx:2234
 TMath.cxx:2235
 TMath.cxx:2236
 TMath.cxx:2237
 TMath.cxx:2238
 TMath.cxx:2239
 TMath.cxx:2240
 TMath.cxx:2241
 TMath.cxx:2242
 TMath.cxx:2243
 TMath.cxx:2244
 TMath.cxx:2245
 TMath.cxx:2246
 TMath.cxx:2247
 TMath.cxx:2248
 TMath.cxx:2249
 TMath.cxx:2250
 TMath.cxx:2251
 TMath.cxx:2252
 TMath.cxx:2253
 TMath.cxx:2254
 TMath.cxx:2255
 TMath.cxx:2256
 TMath.cxx:2257
 TMath.cxx:2258
 TMath.cxx:2259
 TMath.cxx:2260
 TMath.cxx:2261
 TMath.cxx:2262
 TMath.cxx:2263
 TMath.cxx:2264
 TMath.cxx:2265
 TMath.cxx:2266
 TMath.cxx:2267
 TMath.cxx:2268
 TMath.cxx:2269
 TMath.cxx:2270
 TMath.cxx:2271
 TMath.cxx:2272
 TMath.cxx:2273
 TMath.cxx:2274
 TMath.cxx:2275
 TMath.cxx:2276
 TMath.cxx:2277
 TMath.cxx:2278
 TMath.cxx:2279
 TMath.cxx:2280
 TMath.cxx:2281
 TMath.cxx:2282
 TMath.cxx:2283
 TMath.cxx:2284
 TMath.cxx:2285
 TMath.cxx:2286
 TMath.cxx:2287
 TMath.cxx:2288
 TMath.cxx:2289
 TMath.cxx:2290
 TMath.cxx:2291
 TMath.cxx:2292
 TMath.cxx:2293
 TMath.cxx:2294
 TMath.cxx:2295
 TMath.cxx:2296
 TMath.cxx:2297
 TMath.cxx:2298
 TMath.cxx:2299
 TMath.cxx:2300
 TMath.cxx:2301
 TMath.cxx:2302
 TMath.cxx:2303
 TMath.cxx:2304
 TMath.cxx:2305
 TMath.cxx:2306
 TMath.cxx:2307
 TMath.cxx:2308
 TMath.cxx:2309
 TMath.cxx:2310
 TMath.cxx:2311
 TMath.cxx:2312
 TMath.cxx:2313
 TMath.cxx:2314
 TMath.cxx:2315
 TMath.cxx:2316
 TMath.cxx:2317
 TMath.cxx:2318
 TMath.cxx:2319
 TMath.cxx:2320
 TMath.cxx:2321
 TMath.cxx:2322
 TMath.cxx:2323
 TMath.cxx:2324
 TMath.cxx:2325
 TMath.cxx:2326
 TMath.cxx:2327
 TMath.cxx:2328
 TMath.cxx:2329
 TMath.cxx:2330
 TMath.cxx:2331
 TMath.cxx:2332
 TMath.cxx:2333
 TMath.cxx:2334
 TMath.cxx:2335
 TMath.cxx:2336
 TMath.cxx:2337
 TMath.cxx:2338
 TMath.cxx:2339
 TMath.cxx:2340
 TMath.cxx:2341
 TMath.cxx:2342
 TMath.cxx:2343
 TMath.cxx:2344
 TMath.cxx:2345
 TMath.cxx:2346
 TMath.cxx:2347
 TMath.cxx:2348
 TMath.cxx:2349
 TMath.cxx:2350
 TMath.cxx:2351
 TMath.cxx:2352
 TMath.cxx:2353
 TMath.cxx:2354
 TMath.cxx:2355
 TMath.cxx:2356
 TMath.cxx:2357
 TMath.cxx:2358
 TMath.cxx:2359
 TMath.cxx:2360
 TMath.cxx:2361
 TMath.cxx:2362
 TMath.cxx:2363
 TMath.cxx:2364
 TMath.cxx:2365
 TMath.cxx:2366
 TMath.cxx:2367
 TMath.cxx:2368
 TMath.cxx:2369
 TMath.cxx:2370
 TMath.cxx:2371
 TMath.cxx:2372
 TMath.cxx:2373
 TMath.cxx:2374
 TMath.cxx:2375
 TMath.cxx:2376
 TMath.cxx:2377
 TMath.cxx:2378
 TMath.cxx:2379
 TMath.cxx:2380
 TMath.cxx:2381
 TMath.cxx:2382
 TMath.cxx:2383
 TMath.cxx:2384
 TMath.cxx:2385
 TMath.cxx:2386
 TMath.cxx:2387
 TMath.cxx:2388
 TMath.cxx:2389
 TMath.cxx:2390
 TMath.cxx:2391
 TMath.cxx:2392
 TMath.cxx:2393
 TMath.cxx:2394
 TMath.cxx:2395
 TMath.cxx:2396
 TMath.cxx:2397
 TMath.cxx:2398
 TMath.cxx:2399
 TMath.cxx:2400
 TMath.cxx:2401
 TMath.cxx:2402
 TMath.cxx:2403
 TMath.cxx:2404
 TMath.cxx:2405
 TMath.cxx:2406
 TMath.cxx:2407
 TMath.cxx:2408
 TMath.cxx:2409
 TMath.cxx:2410
 TMath.cxx:2411
 TMath.cxx:2412
 TMath.cxx:2413
 TMath.cxx:2414
 TMath.cxx:2415
 TMath.cxx:2416
 TMath.cxx:2417
 TMath.cxx:2418
 TMath.cxx:2419
 TMath.cxx:2420
 TMath.cxx:2421
 TMath.cxx:2422
 TMath.cxx:2423
 TMath.cxx:2424
 TMath.cxx:2425
 TMath.cxx:2426
 TMath.cxx:2427
 TMath.cxx:2428
 TMath.cxx:2429
 TMath.cxx:2430
 TMath.cxx:2431
 TMath.cxx:2432
 TMath.cxx:2433
 TMath.cxx:2434
 TMath.cxx:2435
 TMath.cxx:2436
 TMath.cxx:2437
 TMath.cxx:2438
 TMath.cxx:2439
 TMath.cxx:2440
 TMath.cxx:2441
 TMath.cxx:2442
 TMath.cxx:2443
 TMath.cxx:2444
 TMath.cxx:2445
 TMath.cxx:2446
 TMath.cxx:2447
 TMath.cxx:2448
 TMath.cxx:2449
 TMath.cxx:2450
 TMath.cxx:2451
 TMath.cxx:2452
 TMath.cxx:2453
 TMath.cxx:2454
 TMath.cxx:2455
 TMath.cxx:2456
 TMath.cxx:2457
 TMath.cxx:2458
 TMath.cxx:2459
 TMath.cxx:2460
 TMath.cxx:2461
 TMath.cxx:2462
 TMath.cxx:2463
 TMath.cxx:2464
 TMath.cxx:2465
 TMath.cxx:2466
 TMath.cxx:2467
 TMath.cxx:2468
 TMath.cxx:2469
 TMath.cxx:2470
 TMath.cxx:2471
 TMath.cxx:2472
 TMath.cxx:2473
 TMath.cxx:2474
 TMath.cxx:2475
 TMath.cxx:2476
 TMath.cxx:2477
 TMath.cxx:2478
 TMath.cxx:2479
 TMath.cxx:2480
 TMath.cxx:2481
 TMath.cxx:2482
 TMath.cxx:2483
 TMath.cxx:2484
 TMath.cxx:2485
 TMath.cxx:2486
 TMath.cxx:2487
 TMath.cxx:2488
 TMath.cxx:2489
 TMath.cxx:2490
 TMath.cxx:2491
 TMath.cxx:2492
 TMath.cxx:2493
 TMath.cxx:2494
 TMath.cxx:2495
 TMath.cxx:2496
 TMath.cxx:2497
 TMath.cxx:2498
 TMath.cxx:2499
 TMath.cxx:2500
 TMath.cxx:2501
 TMath.cxx:2502
 TMath.cxx:2503
 TMath.cxx:2504
 TMath.cxx:2505
 TMath.cxx:2506
 TMath.cxx:2507
 TMath.cxx:2508
 TMath.cxx:2509
 TMath.cxx:2510
 TMath.cxx:2511
 TMath.cxx:2512
 TMath.cxx:2513
 TMath.cxx:2514
 TMath.cxx:2515
 TMath.cxx:2516
 TMath.cxx:2517
 TMath.cxx:2518
 TMath.cxx:2519
 TMath.cxx:2520
 TMath.cxx:2521
 TMath.cxx:2522
 TMath.cxx:2523
 TMath.cxx:2524
 TMath.cxx:2525
 TMath.cxx:2526
 TMath.cxx:2527
 TMath.cxx:2528
 TMath.cxx:2529
 TMath.cxx:2530
 TMath.cxx:2531
 TMath.cxx:2532
 TMath.cxx:2533
 TMath.cxx:2534
 TMath.cxx:2535
 TMath.cxx:2536
 TMath.cxx:2537
 TMath.cxx:2538
 TMath.cxx:2539
 TMath.cxx:2540
 TMath.cxx:2541
 TMath.cxx:2542
 TMath.cxx:2543
 TMath.cxx:2544
 TMath.cxx:2545
 TMath.cxx:2546
 TMath.cxx:2547
 TMath.cxx:2548
 TMath.cxx:2549
 TMath.cxx:2550
 TMath.cxx:2551
 TMath.cxx:2552
 TMath.cxx:2553
 TMath.cxx:2554
 TMath.cxx:2555
 TMath.cxx:2556
 TMath.cxx:2557
 TMath.cxx:2558
 TMath.cxx:2559
 TMath.cxx:2560
 TMath.cxx:2561
 TMath.cxx:2562
 TMath.cxx:2563
 TMath.cxx:2564
 TMath.cxx:2565
 TMath.cxx:2566
 TMath.cxx:2567
 TMath.cxx:2568
 TMath.cxx:2569
 TMath.cxx:2570
 TMath.cxx:2571
 TMath.cxx:2572
 TMath.cxx:2573
 TMath.cxx:2574
 TMath.cxx:2575
 TMath.cxx:2576
 TMath.cxx:2577
 TMath.cxx:2578
 TMath.cxx:2579
 TMath.cxx:2580
 TMath.cxx:2581
 TMath.cxx:2582
 TMath.cxx:2583
 TMath.cxx:2584
 TMath.cxx:2585
 TMath.cxx:2586
 TMath.cxx:2587
 TMath.cxx:2588
 TMath.cxx:2589
 TMath.cxx:2590
 TMath.cxx:2591
 TMath.cxx:2592
 TMath.cxx:2593
 TMath.cxx:2594
 TMath.cxx:2595
 TMath.cxx:2596
 TMath.cxx:2597
 TMath.cxx:2598
 TMath.cxx:2599
 TMath.cxx:2600
 TMath.cxx:2601
 TMath.cxx:2602
 TMath.cxx:2603
 TMath.cxx:2604
 TMath.cxx:2605
 TMath.cxx:2606
 TMath.cxx:2607
 TMath.cxx:2608
 TMath.cxx:2609
 TMath.cxx:2610
 TMath.cxx:2611
 TMath.cxx:2612
 TMath.cxx:2613
 TMath.cxx:2614
 TMath.cxx:2615
 TMath.cxx:2616
 TMath.cxx:2617
 TMath.cxx:2618
 TMath.cxx:2619
 TMath.cxx:2620
 TMath.cxx:2621
 TMath.cxx:2622
 TMath.cxx:2623
 TMath.cxx:2624
 TMath.cxx:2625
 TMath.cxx:2626
 TMath.cxx:2627
 TMath.cxx:2628
 TMath.cxx:2629
 TMath.cxx:2630
 TMath.cxx:2631
 TMath.cxx:2632
 TMath.cxx:2633
 TMath.cxx:2634
 TMath.cxx:2635
 TMath.cxx:2636
 TMath.cxx:2637
 TMath.cxx:2638
 TMath.cxx:2639
 TMath.cxx:2640
 TMath.cxx:2641
 TMath.cxx:2642
 TMath.cxx:2643
 TMath.cxx:2644
 TMath.cxx:2645
 TMath.cxx:2646
 TMath.cxx:2647
 TMath.cxx:2648
 TMath.cxx:2649
 TMath.cxx:2650
 TMath.cxx:2651
 TMath.cxx:2652
 TMath.cxx:2653
 TMath.cxx:2654
 TMath.cxx:2655
 TMath.cxx:2656
 TMath.cxx:2657
 TMath.cxx:2658
 TMath.cxx:2659
 TMath.cxx:2660
 TMath.cxx:2661
 TMath.cxx:2662
 TMath.cxx:2663
 TMath.cxx:2664
 TMath.cxx:2665
 TMath.cxx:2666
 TMath.cxx:2667
 TMath.cxx:2668
 TMath.cxx:2669
 TMath.cxx:2670
 TMath.cxx:2671
 TMath.cxx:2672
 TMath.cxx:2673
 TMath.cxx:2674
 TMath.cxx:2675
 TMath.cxx:2676
 TMath.cxx:2677
 TMath.cxx:2678
 TMath.cxx:2679
 TMath.cxx:2680
 TMath.cxx:2681
 TMath.cxx:2682
 TMath.cxx:2683
 TMath.cxx:2684
 TMath.cxx:2685
 TMath.cxx:2686
 TMath.cxx:2687
 TMath.cxx:2688
 TMath.cxx:2689
 TMath.cxx:2690
 TMath.cxx:2691
 TMath.cxx:2692
 TMath.cxx:2693
 TMath.cxx:2694
 TMath.cxx:2695
 TMath.cxx:2696
 TMath.cxx:2697
 TMath.cxx:2698
 TMath.cxx:2699
 TMath.cxx:2700
 TMath.cxx:2701
 TMath.cxx:2702
 TMath.cxx:2703
 TMath.cxx:2704
 TMath.cxx:2705
 TMath.cxx:2706
 TMath.cxx:2707
 TMath.cxx:2708
 TMath.cxx:2709
 TMath.cxx:2710
 TMath.cxx:2711
 TMath.cxx:2712
 TMath.cxx:2713
 TMath.cxx:2714
 TMath.cxx:2715
 TMath.cxx:2716
 TMath.cxx:2717
 TMath.cxx:2718
 TMath.cxx:2719
 TMath.cxx:2720
 TMath.cxx:2721
 TMath.cxx:2722
 TMath.cxx:2723
 TMath.cxx:2724
 TMath.cxx:2725
 TMath.cxx:2726
 TMath.cxx:2727
 TMath.cxx:2728
 TMath.cxx:2729
 TMath.cxx:2730
 TMath.cxx:2731
 TMath.cxx:2732
 TMath.cxx:2733
 TMath.cxx:2734
 TMath.cxx:2735
 TMath.cxx:2736
 TMath.cxx:2737
 TMath.cxx:2738
 TMath.cxx:2739
 TMath.cxx:2740
 TMath.cxx:2741
 TMath.cxx:2742
 TMath.cxx:2743
 TMath.cxx:2744
 TMath.cxx:2745
 TMath.cxx:2746
 TMath.cxx:2747
 TMath.cxx:2748
 TMath.cxx:2749
 TMath.cxx:2750
 TMath.cxx:2751
 TMath.cxx:2752
 TMath.cxx:2753
 TMath.cxx:2754
 TMath.cxx:2755
 TMath.cxx:2756
 TMath.cxx:2757
 TMath.cxx:2758
 TMath.cxx:2759
 TMath.cxx:2760
 TMath.cxx:2761
 TMath.cxx:2762
 TMath.cxx:2763
 TMath.cxx:2764
 TMath.cxx:2765
 TMath.cxx:2766
 TMath.cxx:2767
 TMath.cxx:2768
 TMath.cxx:2769
 TMath.cxx:2770
 TMath.cxx:2771
 TMath.cxx:2772
 TMath.cxx:2773
 TMath.cxx:2774
 TMath.cxx:2775
 TMath.cxx:2776
 TMath.cxx:2777
 TMath.cxx:2778
 TMath.cxx:2779
 TMath.cxx:2780
 TMath.cxx:2781
 TMath.cxx:2782
 TMath.cxx:2783
 TMath.cxx:2784
 TMath.cxx:2785
 TMath.cxx:2786
 TMath.cxx:2787
 TMath.cxx:2788
 TMath.cxx:2789
 TMath.cxx:2790
 TMath.cxx:2791
 TMath.cxx:2792
 TMath.cxx:2793
 TMath.cxx:2794
 TMath.cxx:2795
 TMath.cxx:2796
 TMath.cxx:2797
 TMath.cxx:2798
 TMath.cxx:2799
 TMath.cxx:2800
 TMath.cxx:2801
 TMath.cxx:2802
 TMath.cxx:2803
 TMath.cxx:2804
 TMath.cxx:2805
 TMath.cxx:2806
 TMath.cxx:2807
 TMath.cxx:2808
 TMath.cxx:2809
 TMath.cxx:2810
 TMath.cxx:2811
 TMath.cxx:2812
 TMath.cxx:2813
 TMath.cxx:2814
 TMath.cxx:2815
 TMath.cxx:2816
 TMath.cxx:2817
 TMath.cxx:2818
 TMath.cxx:2819
 TMath.cxx:2820
 TMath.cxx:2821
 TMath.cxx:2822
 TMath.cxx:2823
 TMath.cxx:2824
 TMath.cxx:2825
 TMath.cxx:2826
 TMath.cxx:2827
 TMath.cxx:2828
 TMath.cxx:2829
 TMath.cxx:2830
 TMath.cxx:2831
 TMath.cxx:2832
 TMath.cxx:2833
 TMath.cxx:2834
 TMath.cxx:2835
 TMath.cxx:2836
 TMath.cxx:2837
 TMath.cxx:2838
 TMath.cxx:2839
 TMath.cxx:2840
 TMath.cxx:2841
 TMath.cxx:2842
 TMath.cxx:2843
 TMath.cxx:2844
 TMath.cxx:2845
 TMath.cxx:2846
 TMath.cxx:2847
 TMath.cxx:2848
 TMath.cxx:2849
 TMath.cxx:2850
 TMath.cxx:2851
 TMath.cxx:2852
 TMath.cxx:2853
 TMath.cxx:2854
 TMath.cxx:2855
 TMath.cxx:2856
 TMath.cxx:2857
 TMath.cxx:2858
 TMath.cxx:2859
 TMath.cxx:2860
 TMath.cxx:2861
 TMath.cxx:2862
 TMath.cxx:2863
 TMath.cxx:2864
 TMath.cxx:2865
 TMath.cxx:2866
 TMath.cxx:2867
 TMath.cxx:2868
 TMath.cxx:2869
 TMath.cxx:2870
 TMath.cxx:2871
 TMath.cxx:2872
 TMath.cxx:2873
 TMath.cxx:2874
 TMath.cxx:2875
 TMath.cxx:2876
 TMath.cxx:2877
 TMath.cxx:2878
 TMath.cxx:2879
 TMath.cxx:2880
 TMath.cxx:2881
 TMath.cxx:2882
 TMath.cxx:2883
 TMath.cxx:2884
 TMath.cxx:2885
 TMath.cxx:2886
 TMath.cxx:2887
 TMath.cxx:2888
 TMath.cxx:2889
 TMath.cxx:2890
 TMath.cxx:2891
 TMath.cxx:2892
 TMath.cxx:2893
 TMath.cxx:2894
 TMath.cxx:2895
 TMath.cxx:2896
 TMath.cxx:2897
 TMath.cxx:2898
 TMath.cxx:2899
 TMath.cxx:2900
 TMath.cxx:2901
 TMath.cxx:2902
 TMath.cxx:2903
 TMath.cxx:2904
 TMath.cxx:2905
 TMath.cxx:2906
 TMath.cxx:2907
 TMath.cxx:2908
 TMath.cxx:2909
 TMath.cxx:2910
 TMath.cxx:2911
 TMath.cxx:2912
 TMath.cxx:2913
 TMath.cxx:2914
 TMath.cxx:2915
 TMath.cxx:2916
 TMath.cxx:2917
 TMath.cxx:2918
 TMath.cxx:2919
 TMath.cxx:2920
 TMath.cxx:2921
 TMath.cxx:2922
 TMath.cxx:2923
 TMath.cxx:2924
 TMath.cxx:2925
 TMath.cxx:2926
 TMath.cxx:2927
 TMath.cxx:2928
 TMath.cxx:2929
 TMath.cxx:2930
 TMath.cxx:2931
 TMath.cxx:2932
 TMath.cxx:2933
 TMath.cxx:2934
 TMath.cxx:2935
 TMath.cxx:2936
 TMath.cxx:2937
 TMath.cxx:2938
 TMath.cxx:2939
 TMath.cxx:2940
 TMath.cxx:2941
 TMath.cxx:2942
 TMath.cxx:2943
 TMath.cxx:2944
 TMath.cxx:2945
 TMath.cxx:2946
 TMath.cxx:2947
 TMath.cxx:2948
 TMath.cxx:2949
 TMath.cxx:2950
 TMath.cxx:2951
 TMath.cxx:2952
 TMath.cxx:2953
 TMath.cxx:2954
 TMath.cxx:2955
 TMath.cxx:2956
 TMath.cxx:2957
 TMath.cxx:2958
 TMath.cxx:2959
 TMath.cxx:2960
 TMath.cxx:2961
 TMath.cxx:2962
 TMath.cxx:2963
 TMath.cxx:2964
 TMath.cxx:2965
 TMath.cxx:2966
 TMath.cxx:2967
 TMath.cxx:2968
 TMath.cxx:2969
 TMath.cxx:2970
 TMath.cxx:2971
 TMath.cxx:2972
 TMath.cxx:2973
 TMath.cxx:2974
 TMath.cxx:2975
 TMath.cxx:2976
 TMath.cxx:2977
 TMath.cxx:2978
 TMath.cxx:2979
 TMath.cxx:2980
 TMath.cxx:2981
 TMath.cxx:2982
 TMath.cxx:2983
 TMath.cxx:2984
 TMath.cxx:2985
 TMath.cxx:2986
 TMath.cxx:2987
 TMath.cxx:2988
 TMath.cxx:2989
 TMath.cxx:2990
 TMath.cxx:2991
 TMath.cxx:2992
 TMath.cxx:2993
 TMath.cxx:2994
 TMath.cxx:2995
 TMath.cxx:2996
 TMath.cxx:2997
 TMath.cxx:2998
 TMath.cxx:2999
 TMath.cxx:3000
 TMath.cxx:3001
 TMath.cxx:3002
 TMath.cxx:3003
 TMath.cxx:3004
 TMath.cxx:3005
 TMath.cxx:3006
 TMath.cxx:3007
 TMath.cxx:3008
 TMath.cxx:3009
 TMath.cxx:3010
 TMath.cxx:3011
 TMath.cxx:3012
 TMath.cxx:3013
 TMath.cxx:3014
 TMath.cxx:3015
 TMath.cxx:3016
 TMath.cxx:3017
 TMath.cxx:3018
 TMath.cxx:3019
 TMath.cxx:3020
 TMath.cxx:3021
 TMath.cxx:3022
 TMath.cxx:3023
 TMath.cxx:3024
 TMath.cxx:3025
 TMath.cxx:3026
 TMath.cxx:3027
 TMath.cxx:3028
 TMath.cxx:3029
 TMath.cxx:3030
 TMath.cxx:3031
 TMath.cxx:3032
 TMath.cxx:3033
 TMath.cxx:3034
 TMath.cxx:3035
 TMath.cxx:3036
 TMath.cxx:3037
 TMath.cxx:3038
 TMath.cxx:3039
 TMath.cxx:3040
 TMath.cxx:3041
 TMath.cxx:3042
 TMath.cxx:3043