```// @(#)root/mathcore:\$Id\$
// Author: Rene Brun, Lorenzo Moneta   15/12/95

/*************************************************************************
*                                                                       *
* For the licensing terms see \$ROOTSYS/LICENSE.                         *
* For the list of contributors see \$ROOTSYS/README/CREDITS.             *
*************************************************************************/

//////////////////////////////////////////////////////////////////////////
//
// TRandom
//
// basic Random number generator class (periodicity = 10**9).
// Note that this is a very simple generator (linear congruential)
// which is known to have defects (the lower random bits are correlated)
// and therefore should NOT be used in any statistical study.
// One should use instead TRandom1, TRandom2 or TRandom3.
// TRandom3, is based on the "Mersenne Twister generator", and is the recommended one,
// since it has good random proprieties (period of about 10**6000 ) and it is fast.
// TRandom1, based on the RANLUX algorithm, has mathematically proven random proprieties
// and a period of about 10**171. It is however slower than the others.
// TRandom2, is based on the Tausworthe generator of L'Ecuyer, and it has the advantage
// of being fast and using only 3 words (of 32 bits) for the state. The period is 10**26.
//
// The following table shows some timings (in nanoseconds/call)
// for the random numbers obtained using an Intel Pentium 3.0 GHz running Linux
// and using the gcc 3.2.3 compiler
//
//    TRandom           34   ns/call     (BAD Generator)
//    TRandom1          242  ns/call
//    TRandom2          37   ns/call
//    TRandom3          45   ns/call
//
//
// The following basic Random distributions are provided:
// ===================================================
//   -Exp(tau)
//   -Integer(imax)
//   -Gaus(mean,sigma)
//   -Rndm()
//   -Uniform(x1)
//   -Landau(mpv,sigma)
//   -Poisson(mean)
//   -Binomial(ntot,prob)
//
// Random numbers distributed according to 1-d, 2-d or 3-d distributions
// =====================================================================
// contained in TF1, TF2 or TF3 objects.
// For example, to get a random number distributed following abs(sin(x)/x)*sqrt(x)
// you can do :
//   TF1 *f1 = new TF1("f1","abs(sin(x)/x)*sqrt(x)",0,10);
//   double r = f1->GetRandom();
// or you can use the UNURAN package. You need in this case to initialize UNURAN
// to the function you would like to generate.
//   TUnuran u;
//   u.Init(TUnuranDistrCont(f1));
//   double r = u.Sample();
//
// The techniques of using directly a TF1,2 or 3 function is powerful and
// can be used to generate numbers in the defined range of the function.
// Getting a number from a TF1,2,3 function is also quite fast.
// UNURAN is a  powerful and flexible tool which containes various methods for
// generate random numbers for continuous distributions of one and multi-dimension.
// It requires some set-up (initialization) phase and can be very fast when the distribution
// parameters are not changed for every call.
//
// The following table shows some timings (in nanosecond/call)
// for basic functions,  TF1 functions and using UNURAN obtained running
// the tutorial math/testrandom.C
// Numbers have been obtained on an Intel Xeon Quad-core Harpertown (E5410) 2.33 GHz running
// Linux SLC4 64 bit and compiled with gcc 3.4
//
// Distribution            nanoseconds/call
//                     TRandom  TRandom1 TRandom2 TRandom3
// Rndm..............    5.000  105.000    7.000   10.000
// RndmArray.........    4.000  104.000    6.000    9.000
// Gaus..............   36.000  180.000   40.000   48.000
// Rannor............  118.000  220.000  120.000  124.000
// Landau............   22.000  123.000   26.000   31.000
// Exponential.......   93.000  198.000   98.000  104.000
// Binomial(5,0.5)...   30.000  548.000   46.000   65.000
// Binomial(15,0.5)..   75.000 1615.000  125.000  178.000
// Poisson(3)........   96.000  494.000  109.000  125.000
// Poisson(10).......  138.000 1236.000  165.000  203.000
// Poisson(70).......  818.000 1195.000  835.000  844.000
// Poisson(100)......  837.000 1218.000  849.000  864.000
// GausTF1...........   83.000  180.000   87.000   88.000
// LandauTF1.........   80.000  180.000   83.000   86.000
// GausUNURAN........   40.000  139.000   41.000   44.000
// PoissonUNURAN(10).   85.000  271.000   92.000  102.000
// PoissonUNURAN(100)   62.000  256.000   69.000   78.000
//
//  Note that the time to generate a number from an arbitrary TF1 function
//  using TF1::GetRandom or using TUnuran is  independent of the complexity of the function.
//
//  TH1::FillRandom(TH1 *) or TH1::FillRandom(const char *tf1name)
//  ==============================================================
//  can be used to fill an histogram (1-d, 2-d, 3-d from an existing histogram
//  or from an existing function.
//
//  Note this interesting feature when working with objects
//  =======================================================
//  You can use several TRandom objects, each with their "independent"
//  random sequence. For example, one can imagine
//     TRandom *eventGenerator = new TRandom();
//     TRandom *tracking       = new TRandom();
//  eventGenerator can be used to generate the event kinematics.
//  tracking can be used to track the generated particles with random numbers
//  independent from eventGenerator.
//  This very interesting feature gives the possibility to work with simple
//  and very fast random number generators without worrying about
//  random number periodicity as it was the case with Fortran.
//  One can use TRandom::SetSeed to modify the seed of one generator.
//
//  a TRandom object may be written to a Root file
//  ==============================================
//    -as part of another object
//    -or with its own key (example gRandom->Write("Random");
//
//////////////////////////////////////////////////////////////////////////

#include "TROOT.h"
#include "TMath.h"
#include "TRandom.h"
#include "TRandom3.h"
#include "TSystem.h"
#include "TDirectory.h"
#include "Math/QuantFuncMathCore.h"
#include "TUUID.h"

ClassImp(TRandom)

//______________________________________________________________________________
TRandom::TRandom(UInt_t seed): TNamed("Random","Default Random number generator")
{
// Default constructor. For seed see SetSeed().

SetSeed(seed);
}

//______________________________________________________________________________
TRandom::~TRandom()
{
// Default destructor. Can reset gRandom to 0 if gRandom points to this
// generator.

if (gRandom == this) gRandom = 0;
}

//______________________________________________________________________________
Int_t TRandom::Binomial(Int_t ntot, Double_t prob)
{
// Generates a random integer N according to the binomial law.
// Coded from Los Alamos report LA-5061-MS.
//
// N is binomially distributed between 0 and ntot inclusive
// with mean prob*ntot and prob is between 0 and 1.
//
// Note: This function should not be used when ntot is large (say >100).
// The normal approximation is then recommended instead
// (with mean =*ntot+0.5 and standard deviation sqrt(ntot*prob*(1-prob)).

if (prob < 0 || prob > 1) return 0;
Int_t n = 0;
for (Int_t i=0;i<ntot;i++) {
if (Rndm() > prob) continue;
n++;
}
return n;
}

//______________________________________________________________________________
Double_t TRandom::BreitWigner(Double_t mean, Double_t gamma)
{
// Return a number distributed following a BreitWigner function with mean and gamma.

Double_t rval, displ;
rval = 2*Rndm() - 1;
displ = 0.5*gamma*TMath::Tan(rval*TMath::PiOver2());

return (mean+displ);
}

//______________________________________________________________________________
void TRandom::Circle(Double_t &x, Double_t &y, Double_t r)
{
// Generates random vectors, uniformly distributed over a circle of given radius.
//   Input : r = circle radius
//   Output: x,y a random 2-d vector of length r

Double_t phi = Uniform(0,TMath::TwoPi());
x = r*TMath::Cos(phi);
y = r*TMath::Sin(phi);
}

//______________________________________________________________________________
Double_t TRandom::Exp(Double_t tau)
{
// Returns an exponential deviate.
//
//          exp( -t/tau )

Double_t x = Rndm();              // uniform on ] 0, 1 ]
Double_t t = -tau * TMath::Log( x ); // convert to exponential distribution
return t;
}

//______________________________________________________________________________
Double_t TRandom::Gaus(Double_t mean, Double_t sigma)
{
// Samples a random number from the standard Normal (Gaussian) Distribution
// with the given mean and sigma.
// Uses the Acceptance-complement ratio from W. Hoermann and G. Derflinger
// This is one of the fastest existing method for generating normal random variables.
// It is a factor 2/3 faster than the polar (Box-Muller) method used in the previous
// version of TRandom::Gaus. The speed is comparable to the Ziggurat method (from Marsaglia)
// implemented for example in GSL and available in the MathMore library.
//
// REFERENCE:  - W. Hoermann and G. Derflinger (1990):
//              The ACR Method for generating normal random variables,
//              OR Spektrum 12 (1990), 181-185.
//
// Implementation taken from
// UNURAN (c) 2000  W. Hoermann & J. Leydold, Institut f. Statistik, WU Wien

const Double_t kC1 = 1.448242853;
const Double_t kC2 = 3.307147487;
const Double_t kC3 = 1.46754004;
const Double_t kD1 = 1.036467755;
const Double_t kD2 = 5.295844968;
const Double_t kD3 = 3.631288474;
const Double_t kHm = 0.483941449;
const Double_t kZm = 0.107981933;
const Double_t kHp = 4.132731354;
const Double_t kZp = 18.52161694;
const Double_t kPhln = 0.4515827053;
const Double_t kHm1 = 0.516058551;
const Double_t kHp1 = 3.132731354;
const Double_t kHzm = 0.375959516;
const Double_t kHzmp = 0.591923442;
/*zhm 0.967882898*/

const Double_t kAs = 0.8853395638;
const Double_t kBs = 0.2452635696;
const Double_t kCs = 0.2770276848;
const Double_t kB  = 0.5029324303;
const Double_t kX0 = 0.4571828819;
const Double_t kYm = 0.187308492 ;
const Double_t kS  = 0.7270572718 ;
const Double_t kT  = 0.03895759111;

Double_t result;
Double_t rn,x,y,z;

do {
y = Rndm();

if (y>kHm1) {
result = kHp*y-kHp1; break; }

else if (y<kZm) {
rn = kZp*y-1;
result = (rn>0) ? (1+rn) : (-1+rn);
break;
}

else if (y<kHm) {
rn = Rndm();
rn = rn-1+rn;
z = (rn>0) ? 2-rn : -2-rn;
if ((kC1-y)*(kC3+TMath::Abs(z))<kC2) {
result = z; break; }
else {
x = rn*rn;
if ((y+kD1)*(kD3+x)<kD2) {
result = rn; break; }
else if (kHzmp-y<exp(-(z*z+kPhln)/2)) {
result = z; break; }
else if (y+kHzm<exp(-(x+kPhln)/2)) {
result = rn; break; }
}
}

while (1) {
x = Rndm();
y = kYm * Rndm();
z = kX0 - kS*x - y;
if (z>0)
rn = 2+y/x;
else {
x = 1-x;
y = kYm-y;
rn = -(2+y/x);
}
if ((y-kAs+x)*(kCs+x)+kBs<0) {
result = rn; break; }
else if (y<x+kT)
if (rn*rn<4*(kB-log(x))) {
result = rn; break; }
}
} while(0);

return mean + sigma * result;
}

//______________________________________________________________________________
UInt_t TRandom::Integer(UInt_t imax)
{
// Returns a random integer on [ 0, imax-1 ].

UInt_t ui;
ui = (UInt_t)(imax*Rndm());
return ui;
}

//______________________________________________________________________________
Double_t TRandom::Landau(Double_t mu, Double_t sigma)
{
// Generate a random number following a Landau distribution
// with location parameter mu and scale parameter sigma:
//      Landau( (x-mu)/sigma )
// Note that mu is not the mpv(most probable value) of the Landa distribution
// and sigma is not the standard deviation of the distribution which is not defined.
// For mu  =0 and sigma=1, the mpv = -0.22278
//
// The Landau random number generation is implemented using the
// function landau_quantile(x,sigma), which provides
// the inverse of the landau cumulative distribution.
// landau_quantile has been converted from CERNLIB ranlan(G110).

if (sigma <= 0) return 0;
Double_t x = Rndm();
Double_t res = mu + ROOT::Math::landau_quantile(x, sigma);
return res;
}

//______________________________________________________________________________
Int_t TRandom::Poisson(Double_t mean)
{
// Generates a random integer N according to a Poisson law.
// Prob(N) = exp(-mean)*mean^N/Factorial(N)
//
// Use a different procedure according to the mean value.
// The algorithm is the same used by CLHEP.
// For lower value (mean < 25) use the rejection method based on
// the exponential.
// For higher values use a rejection method comparing with a Lorentzian
// distribution, as suggested by several authors.
// This routine since is returning 32 bits integer will not work for values
// larger than 2*10**9.
// One should then use the Trandom::PoissonD for such large values.

Int_t n;
if (mean <= 0) return 0;
if (mean < 25) {
Double_t expmean = TMath::Exp(-mean);
Double_t pir = 1;
n = -1;
while(1) {
n++;
pir *= Rndm();
if (pir <= expmean) break;
}
return n;
}
// for large value we use inversion method
else if (mean < 1E9) {
Double_t em, t, y;
Double_t sq, alxm, g;
Double_t pi = TMath::Pi();

sq = TMath::Sqrt(2.0*mean);
alxm = TMath::Log(mean);
g = mean*alxm - TMath::LnGamma(mean + 1.0);

do {
do {
y = TMath::Tan(pi*Rndm());
em = sq*y + mean;
} while( em < 0.0 );

em = TMath::Floor(em);
t = 0.9*(1.0 + y*y)* TMath::Exp(em*alxm - TMath::LnGamma(em + 1.0) - g);
} while( Rndm() > t );

return static_cast<Int_t> (em);

}
else {
// use Gaussian approximation vor very large values
n = Int_t(Gaus(0,1)*TMath::Sqrt(mean) + mean +0.5);
return n;
}
}

//______________________________________________________________________________
Double_t TRandom::PoissonD(Double_t mean)
{
// Generates a random number according to a Poisson law.
// Prob(N) = exp(-mean)*mean^N/Factorial(N)
//
// This function is a variant of TRandom::Poisson returning a double

Int_t n;
if (mean <= 0) return 0;
if (mean < 25) {
Double_t expmean = TMath::Exp(-mean);
Double_t pir = 1;
n = -1;
while(1) {
n++;
pir *= Rndm();
if (pir <= expmean) break;
}
return static_cast<Double_t>(n);
}
// for large value we use inversion method
else if (mean < 1E9) {
Double_t em, t, y;
Double_t sq, alxm, g;
Double_t pi = TMath::Pi();

sq = TMath::Sqrt(2.0*mean);
alxm = TMath::Log(mean);
g = mean*alxm - TMath::LnGamma(mean + 1.0);

do {
do {
y = TMath::Tan(pi*Rndm());
em = sq*y + mean;
} while( em < 0.0 );

em = TMath::Floor(em);
t = 0.9*(1.0 + y*y)* TMath::Exp(em*alxm - TMath::LnGamma(em + 1.0) - g);
} while( Rndm() > t );

return em;

} else {
// use Gaussian approximation vor very large values
return Gaus(0,1)*TMath::Sqrt(mean) + mean +0.5;
}
}

//______________________________________________________________________________
void TRandom::Rannor(Float_t &a, Float_t &b)
{
// Return 2 numbers distributed following a gaussian with mean=0 and sigma=1.

Double_t r, x, y, z;

y = Rndm();
z = Rndm();
x = z * 6.28318530717958623;
r = TMath::Sqrt(-2*TMath::Log(y));
a = (Float_t)(r * TMath::Sin(x));
b = (Float_t)(r * TMath::Cos(x));
}

//______________________________________________________________________________
void TRandom::Rannor(Double_t &a, Double_t &b)
{
// Return 2 numbers distributed following a gaussian with mean=0 and sigma=1.

Double_t r, x, y, z;

y = Rndm();
z = Rndm();
x = z * 6.28318530717958623;
r = TMath::Sqrt(-2*TMath::Log(y));
a = r * TMath::Sin(x);
b = r * TMath::Cos(x);
}

//_____________________________________________________________________________
{
// Reads saved random generator status from filename.

if (!gDirectory) return;
char *fntmp = gSystem->ExpandPathName(filename);
TDirectory *file = (TDirectory*)gROOT->ProcessLine(Form("TFile::Open(\"%s\");",fntmp));
delete [] fntmp;
if(file && file->GetFile()) {
delete file;
}
}

//______________________________________________________________________________
Double_t TRandom::Rndm(Int_t)
{
//  Machine independent random number generator.
//  Based on the BSD Unix (Rand) Linear congrential generator.
//  Produces uniformly-distributed floating points between 0 and 1.
//  Identical sequence on all machines of >= 32 bits.
//  Periodicity = 2**31, generates a number in (0,1).
//  Note that this is a generator which is known to have defects
//  (the lower random bits are correlated) and therefore should NOT be
//  used in any statistical study).

#ifdef OLD_TRANDOM_IMPL
const Double_t kCONS = 4.6566128730774E-10;

fSeed *= 69069;
UInt_t jy = (fSeed&kMASK24); // Set lower 8 bits to zero to assure exact float
if (jy) return kCONS*jy;
return Rndm();
#endif

// kCONS = 1./2147483648 = 1./(RAND_MAX+1) and RAND_MAX= 0x7fffffffUL
const Double_t kCONS = 4.6566128730774E-10; // (1/pow(2,31)
fSeed = (1103515245 * fSeed + 12345) & 0x7fffffffUL;

if (fSeed) return  kCONS*fSeed;
return Rndm();
}

//______________________________________________________________________________
void TRandom::RndmArray(Int_t n, Double_t *array)
{
// Return an array of n random numbers uniformly distributed in ]0,1].

const Double_t kCONS = 4.6566128730774E-10; // (1/pow(2,31))
Int_t i=0;
while (i<n) {
fSeed = (1103515245 * fSeed + 12345) & 0x7fffffffUL;
if (fSeed) {array[i] = kCONS*fSeed; i++;}
}
}

//______________________________________________________________________________
void TRandom::RndmArray(Int_t n, Float_t *array)
{
// Return an array of n random numbers uniformly distributed in ]0,1].

const Double_t kCONS = 4.6566128730774E-10; // (1/pow(2,31))
Int_t i=0;
while (i<n) {
fSeed = (1103515245 * fSeed + 12345) & 0x7fffffffUL;
if (fSeed) {array[i] = Float_t(kCONS*fSeed); i++;}
}
}

//______________________________________________________________________________
void TRandom::SetSeed(UInt_t seed)
{
// Set the random generator seed. Note that default value is zero, which is
// different than the default value used when constructing the class.
// If the seed is zero the seed is set to a random value
// which in case of TRandom depends on the lowest 4 bytes of TUUID
// The UUID will be identical if SetSeed(0) is called with time smaller than 100 ns
// Instead if a different generator implementation is used (TRandom1, 2 or 3)
// the seed is generated using a 128 bit UUID. This results in different seeds
// and then random sequence for every SetSeed(0) call.

if( seed==0 ) {
TUUID u;
UChar_t uuid[16];
u.GetUUID(uuid);
fSeed  =  UInt_t(uuid[3])*16777216 + UInt_t(uuid[2])*65536 + UInt_t(uuid[1])*256 + UInt_t(uuid[0]);
} else {
fSeed = seed;
}
}

//______________________________________________________________________________
void TRandom::Sphere(Double_t &x, Double_t &y, Double_t &z, Double_t r)
{
// Generates random vectors, uniformly distributed over the surface
// of a sphere of given radius.
//   Input : r = sphere radius
//   Output: x,y,z a random 3-d vector of length r
// Method: (based on algorithm suggested by Knuth and attributed to Robert E Knop)
//         which uses less random numbers than the CERNLIB RN23DIM algorithm

Double_t a=0,b=0,r2=1;
while (r2 > 0.25) {
a  = Rndm() - 0.5;
b  = Rndm() - 0.5;
r2 =  a*a + b*b;
}
z = r* ( -1. + 8.0 * r2 );

Double_t scale = 8.0 * r * TMath::Sqrt(0.25 - r2);
x = a*scale;
y = b*scale;
}

//______________________________________________________________________________
Double_t TRandom::Uniform(Double_t x1)
{
// Returns a uniform deviate on the interval  (0, x1).

Double_t ans = Rndm();
return x1*ans;
}

//______________________________________________________________________________
Double_t TRandom::Uniform(Double_t x1, Double_t x2)
{
// Returns a uniform deviate on the interval (x1, x2).

Double_t ans= Rndm();
return x1 + (x2-x1)*ans;
}

//_____________________________________________________________________________
void TRandom::WriteRandom(const char *filename)
{
// Writes random generator status to filename.

if (!gDirectory) return;
char *fntmp = gSystem->ExpandPathName(filename);
TDirectory *file = (TDirectory*)gROOT->ProcessLine(Form("TFile::Open(\"%s\",\"recreate\");",fntmp));
delete [] fntmp;
if(file && file->GetFile()) {
gDirectory->WriteTObject(this,GetName());
delete file;
}
}
```
TRandom.cxx:1
TRandom.cxx:2
TRandom.cxx:3
TRandom.cxx:4
TRandom.cxx:5
TRandom.cxx:6
TRandom.cxx:7
TRandom.cxx:8
TRandom.cxx:9
TRandom.cxx:10
TRandom.cxx:11
TRandom.cxx:12
TRandom.cxx:13
TRandom.cxx:14
TRandom.cxx:15
TRandom.cxx:16
TRandom.cxx:17
TRandom.cxx:18
TRandom.cxx:19
TRandom.cxx:20
TRandom.cxx:21
TRandom.cxx:22
TRandom.cxx:23
TRandom.cxx:24
TRandom.cxx:25
TRandom.cxx:26
TRandom.cxx:27
TRandom.cxx:28
TRandom.cxx:29
TRandom.cxx:30
TRandom.cxx:31
TRandom.cxx:32
TRandom.cxx:33
TRandom.cxx:34
TRandom.cxx:35
TRandom.cxx:36
TRandom.cxx:37
TRandom.cxx:38
TRandom.cxx:39
TRandom.cxx:40
TRandom.cxx:41
TRandom.cxx:42
TRandom.cxx:43
TRandom.cxx:44
TRandom.cxx:45
TRandom.cxx:46
TRandom.cxx:47
TRandom.cxx:48
TRandom.cxx:49
TRandom.cxx:50
TRandom.cxx:51
TRandom.cxx:52
TRandom.cxx:53
TRandom.cxx:54
TRandom.cxx:55
TRandom.cxx:56
TRandom.cxx:57
TRandom.cxx:58
TRandom.cxx:59
TRandom.cxx:60
TRandom.cxx:61
TRandom.cxx:62
TRandom.cxx:63
TRandom.cxx:64
TRandom.cxx:65
TRandom.cxx:66
TRandom.cxx:67
TRandom.cxx:68
TRandom.cxx:69
TRandom.cxx:70
TRandom.cxx:71
TRandom.cxx:72
TRandom.cxx:73
TRandom.cxx:74
TRandom.cxx:75
TRandom.cxx:76
TRandom.cxx:77
TRandom.cxx:78
TRandom.cxx:79
TRandom.cxx:80
TRandom.cxx:81
TRandom.cxx:82
TRandom.cxx:83
TRandom.cxx:84
TRandom.cxx:85
TRandom.cxx:86
TRandom.cxx:87
TRandom.cxx:88
TRandom.cxx:89
TRandom.cxx:90
TRandom.cxx:91
TRandom.cxx:92
TRandom.cxx:93
TRandom.cxx:94
TRandom.cxx:95
TRandom.cxx:96
TRandom.cxx:97
TRandom.cxx:98
TRandom.cxx:99
TRandom.cxx:100
TRandom.cxx:101
TRandom.cxx:102
TRandom.cxx:103
TRandom.cxx:104
TRandom.cxx:105
TRandom.cxx:106
TRandom.cxx:107
TRandom.cxx:108
TRandom.cxx:109
TRandom.cxx:110
TRandom.cxx:111
TRandom.cxx:112
TRandom.cxx:113
TRandom.cxx:114
TRandom.cxx:115
TRandom.cxx:116
TRandom.cxx:117
TRandom.cxx:118
TRandom.cxx:119
TRandom.cxx:120
TRandom.cxx:121
TRandom.cxx:122
TRandom.cxx:123
TRandom.cxx:124
TRandom.cxx:125
TRandom.cxx:126
TRandom.cxx:127
TRandom.cxx:128
TRandom.cxx:129
TRandom.cxx:130
TRandom.cxx:131
TRandom.cxx:132
TRandom.cxx:133
TRandom.cxx:134
TRandom.cxx:135
TRandom.cxx:136
TRandom.cxx:137
TRandom.cxx:138
TRandom.cxx:139
TRandom.cxx:140
TRandom.cxx:141
TRandom.cxx:142
TRandom.cxx:143
TRandom.cxx:144
TRandom.cxx:145
TRandom.cxx:146
TRandom.cxx:147
TRandom.cxx:148
TRandom.cxx:149
TRandom.cxx:150
TRandom.cxx:151
TRandom.cxx:152
TRandom.cxx:153
TRandom.cxx:154
TRandom.cxx:155
TRandom.cxx:156
TRandom.cxx:157
TRandom.cxx:158
TRandom.cxx:159
TRandom.cxx:160
TRandom.cxx:161
TRandom.cxx:162
TRandom.cxx:163
TRandom.cxx:164
TRandom.cxx:165
TRandom.cxx:166
TRandom.cxx:167
TRandom.cxx:168
TRandom.cxx:169
TRandom.cxx:170
TRandom.cxx:171
TRandom.cxx:172
TRandom.cxx:173
TRandom.cxx:174
TRandom.cxx:175
TRandom.cxx:176
TRandom.cxx:177
TRandom.cxx:178
TRandom.cxx:179
TRandom.cxx:180
TRandom.cxx:181
TRandom.cxx:182
TRandom.cxx:183
TRandom.cxx:184
TRandom.cxx:185
TRandom.cxx:186
TRandom.cxx:187
TRandom.cxx:188
TRandom.cxx:189
TRandom.cxx:190
TRandom.cxx:191
TRandom.cxx:192
TRandom.cxx:193
TRandom.cxx:194
TRandom.cxx:195
TRandom.cxx:196
TRandom.cxx:197
TRandom.cxx:198
TRandom.cxx:199
TRandom.cxx:200
TRandom.cxx:201
TRandom.cxx:202
TRandom.cxx:203
TRandom.cxx:204
TRandom.cxx:205
TRandom.cxx:206
TRandom.cxx:207
TRandom.cxx:208
TRandom.cxx:209
TRandom.cxx:210
TRandom.cxx:211
TRandom.cxx:212
TRandom.cxx:213
TRandom.cxx:214
TRandom.cxx:215
TRandom.cxx:216
TRandom.cxx:217
TRandom.cxx:218
TRandom.cxx:219
TRandom.cxx:220
TRandom.cxx:221
TRandom.cxx:222
TRandom.cxx:223
TRandom.cxx:224
TRandom.cxx:225
TRandom.cxx:226
TRandom.cxx:227
TRandom.cxx:228
TRandom.cxx:229
TRandom.cxx:230
TRandom.cxx:231
TRandom.cxx:232
TRandom.cxx:233
TRandom.cxx:234
TRandom.cxx:235
TRandom.cxx:236
TRandom.cxx:237
TRandom.cxx:238
TRandom.cxx:239
TRandom.cxx:240
TRandom.cxx:241
TRandom.cxx:242
TRandom.cxx:243
TRandom.cxx:244
TRandom.cxx:245
TRandom.cxx:246
TRandom.cxx:247
TRandom.cxx:248
TRandom.cxx:249
TRandom.cxx:250
TRandom.cxx:251
TRandom.cxx:252
TRandom.cxx:253
TRandom.cxx:254
TRandom.cxx:255
TRandom.cxx:256
TRandom.cxx:257
TRandom.cxx:258
TRandom.cxx:259
TRandom.cxx:260
TRandom.cxx:261
TRandom.cxx:262
TRandom.cxx:263
TRandom.cxx:264
TRandom.cxx:265
TRandom.cxx:266
TRandom.cxx:267
TRandom.cxx:268
TRandom.cxx:269
TRandom.cxx:270
TRandom.cxx:271
TRandom.cxx:272
TRandom.cxx:273
TRandom.cxx:274
TRandom.cxx:275
TRandom.cxx:276
TRandom.cxx:277
TRandom.cxx:278
TRandom.cxx:279
TRandom.cxx:280
TRandom.cxx:281
TRandom.cxx:282
TRandom.cxx:283
TRandom.cxx:284
TRandom.cxx:285
TRandom.cxx:286
TRandom.cxx:287
TRandom.cxx:288
TRandom.cxx:289
TRandom.cxx:290
TRandom.cxx:291
TRandom.cxx:292
TRandom.cxx:293
TRandom.cxx:294
TRandom.cxx:295
TRandom.cxx:296
TRandom.cxx:297
TRandom.cxx:298
TRandom.cxx:299
TRandom.cxx:300
TRandom.cxx:301
TRandom.cxx:302
TRandom.cxx:303
TRandom.cxx:304
TRandom.cxx:305
TRandom.cxx:306
TRandom.cxx:307
TRandom.cxx:308
TRandom.cxx:309
TRandom.cxx:310
TRandom.cxx:311
TRandom.cxx:312
TRandom.cxx:313
TRandom.cxx:314
TRandom.cxx:315
TRandom.cxx:316
TRandom.cxx:317
TRandom.cxx:318
TRandom.cxx:319
TRandom.cxx:320
TRandom.cxx:321
TRandom.cxx:322
TRandom.cxx:323
TRandom.cxx:324
TRandom.cxx:325
TRandom.cxx:326
TRandom.cxx:327
TRandom.cxx:328
TRandom.cxx:329
TRandom.cxx:330
TRandom.cxx:331
TRandom.cxx:332
TRandom.cxx:333
TRandom.cxx:334
TRandom.cxx:335
TRandom.cxx:336
TRandom.cxx:337
TRandom.cxx:338
TRandom.cxx:339
TRandom.cxx:340
TRandom.cxx:341
TRandom.cxx:342
TRandom.cxx:343
TRandom.cxx:344
TRandom.cxx:345
TRandom.cxx:346
TRandom.cxx:347
TRandom.cxx:348
TRandom.cxx:349
TRandom.cxx:350
TRandom.cxx:351
TRandom.cxx:352
TRandom.cxx:353
TRandom.cxx:354
TRandom.cxx:355
TRandom.cxx:356
TRandom.cxx:357
TRandom.cxx:358
TRandom.cxx:359
TRandom.cxx:360
TRandom.cxx:361
TRandom.cxx:362
TRandom.cxx:363
TRandom.cxx:364
TRandom.cxx:365
TRandom.cxx:366
TRandom.cxx:367
TRandom.cxx:368
TRandom.cxx:369
TRandom.cxx:370
TRandom.cxx:371
TRandom.cxx:372
TRandom.cxx:373
TRandom.cxx:374
TRandom.cxx:375
TRandom.cxx:376
TRandom.cxx:377
TRandom.cxx:378
TRandom.cxx:379
TRandom.cxx:380
TRandom.cxx:381
TRandom.cxx:382
TRandom.cxx:383
TRandom.cxx:384
TRandom.cxx:385
TRandom.cxx:386
TRandom.cxx:387
TRandom.cxx:388
TRandom.cxx:389
TRandom.cxx:390
TRandom.cxx:391
TRandom.cxx:392
TRandom.cxx:393
TRandom.cxx:394
TRandom.cxx:395
TRandom.cxx:396
TRandom.cxx:397
TRandom.cxx:398
TRandom.cxx:399
TRandom.cxx:400
TRandom.cxx:401
TRandom.cxx:402
TRandom.cxx:403
TRandom.cxx:404
TRandom.cxx:405
TRandom.cxx:406
TRandom.cxx:407
TRandom.cxx:408
TRandom.cxx:409
TRandom.cxx:410
TRandom.cxx:411
TRandom.cxx:412
TRandom.cxx:413
TRandom.cxx:414
TRandom.cxx:415
TRandom.cxx:416
TRandom.cxx:417
TRandom.cxx:418
TRandom.cxx:419
TRandom.cxx:420
TRandom.cxx:421
TRandom.cxx:422
TRandom.cxx:423
TRandom.cxx:424
TRandom.cxx:425
TRandom.cxx:426
TRandom.cxx:427
TRandom.cxx:428
TRandom.cxx:429
TRandom.cxx:430
TRandom.cxx:431
TRandom.cxx:432
TRandom.cxx:433
TRandom.cxx:434
TRandom.cxx:435
TRandom.cxx:436
TRandom.cxx:437
TRandom.cxx:438
TRandom.cxx:439
TRandom.cxx:440
TRandom.cxx:441
TRandom.cxx:442
TRandom.cxx:443
TRandom.cxx:444
TRandom.cxx:445
TRandom.cxx:446
TRandom.cxx:447
TRandom.cxx:448
TRandom.cxx:449
TRandom.cxx:450
TRandom.cxx:451
TRandom.cxx:452
TRandom.cxx:453
TRandom.cxx:454
TRandom.cxx:455
TRandom.cxx:456
TRandom.cxx:457
TRandom.cxx:458
TRandom.cxx:459
TRandom.cxx:460
TRandom.cxx:461
TRandom.cxx:462
TRandom.cxx:463
TRandom.cxx:464
TRandom.cxx:465
TRandom.cxx:466
TRandom.cxx:467
TRandom.cxx:468
TRandom.cxx:469
TRandom.cxx:470
TRandom.cxx:471
TRandom.cxx:472
TRandom.cxx:473
TRandom.cxx:474
TRandom.cxx:475
TRandom.cxx:476
TRandom.cxx:477
TRandom.cxx:478
TRandom.cxx:479
TRandom.cxx:480
TRandom.cxx:481
TRandom.cxx:482
TRandom.cxx:483
TRandom.cxx:484
TRandom.cxx:485
TRandom.cxx:486
TRandom.cxx:487
TRandom.cxx:488
TRandom.cxx:489
TRandom.cxx:490
TRandom.cxx:491
TRandom.cxx:492
TRandom.cxx:493
TRandom.cxx:494
TRandom.cxx:495
TRandom.cxx:496
TRandom.cxx:497
TRandom.cxx:498
TRandom.cxx:499
TRandom.cxx:500
TRandom.cxx:501
TRandom.cxx:502
TRandom.cxx:503
TRandom.cxx:504
TRandom.cxx:505
TRandom.cxx:506
TRandom.cxx:507
TRandom.cxx:508
TRandom.cxx:509
TRandom.cxx:510
TRandom.cxx:511
TRandom.cxx:512
TRandom.cxx:513
TRandom.cxx:514
TRandom.cxx:515
TRandom.cxx:516
TRandom.cxx:517
TRandom.cxx:518
TRandom.cxx:519
TRandom.cxx:520
TRandom.cxx:521
TRandom.cxx:522
TRandom.cxx:523
TRandom.cxx:524
TRandom.cxx:525
TRandom.cxx:526
TRandom.cxx:527
TRandom.cxx:528
TRandom.cxx:529
TRandom.cxx:530
TRandom.cxx:531
TRandom.cxx:532
TRandom.cxx:533
TRandom.cxx:534
TRandom.cxx:535
TRandom.cxx:536
TRandom.cxx:537
TRandom.cxx:538
TRandom.cxx:539
TRandom.cxx:540
TRandom.cxx:541
TRandom.cxx:542
TRandom.cxx:543
TRandom.cxx:544
TRandom.cxx:545
TRandom.cxx:546
TRandom.cxx:547
TRandom.cxx:548
TRandom.cxx:549
TRandom.cxx:550
TRandom.cxx:551
TRandom.cxx:552
TRandom.cxx:553
TRandom.cxx:554
TRandom.cxx:555
TRandom.cxx:556
TRandom.cxx:557
TRandom.cxx:558
TRandom.cxx:559
TRandom.cxx:560
TRandom.cxx:561
TRandom.cxx:562
TRandom.cxx:563
TRandom.cxx:564
TRandom.cxx:565
TRandom.cxx:566
TRandom.cxx:567
TRandom.cxx:568
TRandom.cxx:569
TRandom.cxx:570
TRandom.cxx:571
TRandom.cxx:572
TRandom.cxx:573
TRandom.cxx:574
TRandom.cxx:575
TRandom.cxx:576
TRandom.cxx:577
TRandom.cxx:578
TRandom.cxx:579
TRandom.cxx:580
TRandom.cxx:581
TRandom.cxx:582
TRandom.cxx:583
TRandom.cxx:584
TRandom.cxx:585
TRandom.cxx:586
TRandom.cxx:587
TRandom.cxx:588
TRandom.cxx:589
TRandom.cxx:590
TRandom.cxx:591
TRandom.cxx:592
TRandom.cxx:593
TRandom.cxx:594
TRandom.cxx:595
TRandom.cxx:596
TRandom.cxx:597
TRandom.cxx:598
TRandom.cxx:599
TRandom.cxx:600
TRandom.cxx:601
TRandom.cxx:602
TRandom.cxx:603
TRandom.cxx:604
TRandom.cxx:605
TRandom.cxx:606
TRandom.cxx:607
TRandom.cxx:608
TRandom.cxx:609
TRandom.cxx:610
TRandom.cxx:611
TRandom.cxx:612
TRandom.cxx:613
TRandom.cxx:614
TRandom.cxx:615
TRandom.cxx:616
TRandom.cxx:617
TRandom.cxx:618
TRandom.cxx:619
TRandom.cxx:620
TRandom.cxx:621
TRandom.cxx:622
TRandom.cxx:623
TRandom.cxx:624
TRandom.cxx:625
TRandom.cxx:626