```// @(#)root/hist:\$Id\$
// Author: Nicolas Brun   19/08/95

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

#include <math.h>

#include "Riostream.h"
#include "TROOT.h"
#include "TClass.h"
#include "v5/TFormula.h"
#include "TMath.h"
#include "TRandom.h"
#include "TFunction.h"
#include "TMethodCall.h"
#include "TObjString.h"
#include "TError.h"
#include "v5/TFormulaPrimitive.h"
#include "TInterpreter.h"
#include "TVirtualMutex.h"

#ifdef WIN32
#pragma optimize("",off)
#endif

static Int_t gMAXOP=1000,gMAXPAR=1000,gMAXCONST=1000;
const Int_t  gMAXSTRINGFOUND = 10;
const UInt_t kOptimizationError = BIT(19);

ClassImp(ROOT::v5::TFormula)

namespace ROOT {

namespace v5 {

//______________________________________________________________________________
// The FORMULA class (ROOT version 5)
//
//Begin_Html
/*
<img src="gif/tformula_classtree.gif">
*/
//End_Html
//
//  Example of valid expressions:
//     -  sin(x)/x
//     -  [0]*sin(x) + [1]*exp(-[2]*x)
//     -  x + y**2
//     -  x^2 + y^2
//     -  [0]*pow([1],4)
//     -  2*pi*sqrt(x/y)
//     -  gaus(0)*expo(3)  + ypol3(5)*x
//     -  gausn(0)*expo(3) + ypol3(5)*x
//
//  In the last example above:
//     gaus(0) is a substitute for [0]*exp(-0.5*((x-[1])/[2])**2)
//        and (0) means start numbering parameters at 0
//     gausn(0) is a substitute for [0]*exp(-0.5*((x-[1])/[2])**2)/(sqrt(2*pi)*[2]))
//        and (0) means start numbering parameters at 0
//     expo(3) is a substitute for exp([3]+[4]*x)
//     pol3(5) is a substitute for par[5]+par[6]*x+par[7]*x**2+par[8]*x**3
//         (here Pol3 stands for Polynomial of degree 3)
//
//   TMath functions can be part of the expression, eg:
//     -  TMath::Landau(x)*sin(x)
//     -  TMath::Erf(x)
//
//   Comparisons operators are also supported (&&, ||, ==, <=, >=, !)
//   Examples:
//      sin(x*(x<0.5 || x>1))
//   If the result of a comparison is TRUE, the result is 1, otherwise 0.
//
//   Already predefined names can be given. For example, if the formula
//     TFormula old(sin(x*(x<0.5 || x>1))) one can assign a name to the formula. By default
//     the name of the object = title = formula itself.
//     old.SetName("old").
//     then, old can be reused in a new expression.
//     TFormula new("x*old") is equivalent to:
//     TFormula new("x*sin(x*(x<0.5 || x>1))")
//
//   Up to 4 dimensions are supported (indicated by x, y, z, t)
//   An expression may have 0 parameters or a list of parameters
//   indicated by the sequence [par_number]
//
//   A graph showing the logic to compile and analyze a formula
//   is shown in TFormula::Compile and TFormula::Analyze.
//   Once a formula has been compiled, it can be evaluated for a given
//   set of parameters. see graph in TFormula::EvalPar.
//
//   This class is the base class for the function classes TF1,TF2 and TF3.
//   It is also used by the ntuple selection mechanism TNtupleFormula.
//
//   In version 7 of TFormula, the usage of fOper has been changed
//   to improve the performance of TFormula::EvalPar.
//   Conceptually, fOper was changed from a simple array of Int_t
//   to an array of composite values.
//   For example a 'ylandau(5)' operation used to be encoded as 4105;
//   it is now encoded as (klandau >> kTFOperShit) + 5
//   Any class inheriting from TFormula and using directly fOper (which
//   is now a private data member), needs to be updated to take this
//   in consideration.  The member functions recommended to set and
//   access fOper are:  SetAction, GetAction, GetActionParam
//   TFormula::EvalPar
//
//   CHANGING DEFAULT SETTINGS
//   =========================
//   When creating complex formula , it may be necessary to increase
//   some default parameters. see static function TFormula::SetMaxima
//
//   WHY TFormula CANNOT ACCEPT A CLASS MEMBER FUNCTION ?
//   ====================================================
//   This is a frequently asked question.
//   C++ is a strongly typed language. There is no way for TFormula (without
//   recompiling this class) to know about all possible user defined data types.
//   This also apply to the case of a static class function.
//   Because TMath is a special and frequent case, TFormula is aware
//   of all TMath functions.

//______________________________________________________________________________
TFormula::TFormula(): TNamed()
{
// Formula default constructor.

fNdim   = 0;
fNpar   = 0;
fNoper  = 0;
fNconst = 0;
fNumber = 0;
fExpr   = 0;
fOper   = 0;
fConst  = 0;
fParams = 0;
fNstring= 0;
fNames  = 0;
fNval   = 0;
//
//MI change
fNOperOptimized = 0;
fExprOptimized  = 0;
fOperOptimized  = 0;
fOperOffset     = 0;
fPredefined     = 0;
fOptimal        = (ROOT::v5::TFormulaPrimitive::TFuncG)&TFormula::EvalParOld;
}

//______________________________________________________________________________
TFormula::TFormula(const char *name,const char *expression) :
TNamed(name,expression)
{
// Normal Formula constructor.

fNdim   = 0;
fNpar   = 0;
fNoper  = 0;
fNconst = 0;
fNumber = 0;
fExpr   = 0;
fOper   = 0;
fConst  = 0;
fParams = 0;
fNstring= 0;
fNames  = 0;
fNval   = 0;
//
//MI change
fNOperOptimized = 0;
fExprOptimized  = 0;
fOperOptimized  = 0;
fOperOffset     = 0;
fPredefined     = 0;
fOptimal        = (ROOT::v5::TFormulaPrimitive::TFuncG)&TFormula::EvalParOld;

if (!expression || !*expression) {
Error("TFormula", "expression may not be 0 or have 0 length");
return;
}

//eliminate blanks in expression
Int_t i,j,nch;
nch = strlen(expression);
char *expr = new char[nch+1];
j = 0;
for (i=0;i<nch;i++) {
if (expression[i] == ' ') continue;
if (i > 0 && (expression[i] == '*') && (expression[i-1] == '*')) {
expr[j-1] = '^';
continue;
}
expr[j] = expression[i]; j++;
}
expr[j] = 0;
Bool_t gausNorm   = kFALSE;
Bool_t landauNorm = kFALSE;
Bool_t linear = kFALSE;

if (j) {
TString chaine = expr;
//special case for functions for linear fitting
if (chaine.Contains("++"))
linear = kTRUE;
// special case for normalized gaus
if (chaine.Contains("gausn")) {
gausNorm = kTRUE;
TString tmp = chaine;
tmp.ReplaceAll("gausn","");
tmp.ReplaceAll("landaun","");
if ( tmp.Contains("gaus")  )
Warning("TFormula","Cannot use both gaus and gausn - gaus will be treated as gausn");
if ( tmp.Contains("landau")  )
Warning("TFormula","Cannot use both gausn and landau - landau will be treated as landaun");
}
// special case for normalized landau
if (chaine.Contains("landaun")) {
landauNorm = kTRUE;
TString tmp = chaine;
tmp.ReplaceAll("landaun","");
tmp.ReplaceAll("gausn","");
if ( tmp.Contains("gaus")  ) {
Warning("TFormula","Cannot use both gaus and landaun - gaus will be treated as gausn");
}
if ( tmp.Contains("landau") )
Warning("TFormula","Cannot use both landau and landaun - landau will be treated as landaun");
}
// need to the replacement here for the error message before
if (gausNorm)
chaine.ReplaceAll("gausn","gaus");
if (landauNorm)
chaine.ReplaceAll("landaun","landau");

SetTitle(chaine.Data());
}
delete [] expr;

if (linear)    SetBit(kLinear);

if (Compile()) return;

if (gausNorm)   SetBit(kNormalized);
if (landauNorm) SetBit(kNormalized);

// Store formula in linked list of formula in ROOT

if (strcmp(name,"x")==0 || strcmp(name,"y")==0 ||
strcmp(name,"z")==0 || strcmp(name,"t")==0 )
{
Error("TFormula","The name \'%s\' is reserved as a TFormula variable name.\n"
"\tThis function will not be registered in the list of functions",name);
} else {
R__LOCKGUARD2(gROOTMutex);
TFormula *old = (TFormula*)gROOT->GetListOfFunctions()->FindObject(name);
if (old) {
gROOT->GetListOfFunctions()->Remove(old);
}
}
}

//______________________________________________________________________________
TFormula::TFormula(const TFormula &formula) : TNamed()
{
// Default constructor.

fNdim   = 0;
fNpar   = 0;
fNoper  = 0;
fNconst = 0;
fNumber = 0;
fExpr   = 0;
fOper   = 0;
fConst  = 0;
fParams = 0;
fNstring= 0;
fNames  = 0;
fNval   = 0;
fNOperOptimized = 0;
fPredefined     = 0;
fOperOffset     = 0;
fExprOptimized  = 0;
fOperOptimized  = 0;

((TFormula&)formula).TFormula::Copy(*this);
}

//______________________________________________________________________________
TFormula& TFormula::operator=(const TFormula &rhs)
{
// Operator =

if (this != &rhs) {
rhs.Copy(*this);
}
return *this;
}

//______________________________________________________________________________
TFormula::~TFormula()
{
// Formula default destructor.

if (gROOT) {
R__LOCKGUARD2(gROOTMutex);
gROOT->GetListOfFunctions()->Remove(this);
}

ClearFormula();
}

//______________________________________________________________________________
Bool_t TFormula::AnalyzeFunction(TString &chaine, Int_t &err, Int_t offset)
{
// Check if the chain as function call.
//
//   If you overload this member function, you also HAVE TO
//   never call the constructor:
//
//     TFormula::TFormula(const char *name,const char *expression)
//
//   and write your own constructor
//
//     MyClass::MyClass(const char *name,const char *expression) : TFormula()
//
//   which has to call the TFormula default constructor and whose implementation
//   should be similar to the implementation of the normal TFormula constructor
//
//   This is necessary because the normal TFormula constructor call indirectly
//   the virtual member functions Analyze, DefaultString, DefaultValue
//   and DefaultVariable.

int i;

// We have to decompose the chain is 3 potential components:
//   namespace::functionName( args )

Ssiz_t argStart = chaine.First('(');
if (argStart<0) return false;

TString functionName = chaine(0,argStart);

// This does not support template yet (where the scope operator might be in
// one of the template arguments
Ssiz_t scopeEnd = functionName.Last(':');
TString spaceName;
if (scopeEnd>0 && functionName[scopeEnd-1]==':') {
spaceName = functionName(0,scopeEnd-1);
functionName.Remove(0,scopeEnd+1);
}

// Now we need to count and decompose the actual arguments, we could also check the type
// of the arguments
if (chaine[chaine.Length()-1] != ')') {
Error("AnalyzeFunction","We thought we had a function but we dont (in %s)\n",chaine.Data());
}

TString args = chaine(argStart+1,chaine.Length()-2-argStart);
TObjArray argArr;
argArr.SetOwner(kTRUE);
//fprintf(stderr,"args are '%s'\n",args.Data());

Bool_t inString = false;
int paran = 0;
int brack = 0;
int prevComma = 0;
int nargs = 0;
for(i=0; i<args.Length(); i++) {
if (args[i]=='"') inString = !inString;
if (inString) continue;

Bool_t foundArg = false;
switch(args[i]) {

case '(': paran++; break;
case ')': paran--; break;
case '[': brack++; break;
case ']': brack--; break;

case ',': if (paran==0 && brack==0) { foundArg = true; } break;
}
if ((i+1)==args.Length()) {
foundArg = true; i++;
}
if (foundArg) {
TString arg = args(prevComma,i-prevComma);

// Here we could
//   a) check the type
//fprintf(stderr,"found #%d arg %s\n",nargs,arg.Data());

// We register the arg for later usage
nargs++;

prevComma = i+1;
};
}

if (nargs>999) {
err = 7;
return false;
}

// Now we need to lookup the function and check its arguments.
TClass *ns = (spaceName.Length()) ? TClass::GetClass(spaceName) : 0;
ClassInfo_t *cinfo = 0;
if (ns) {
cinfo = ns->GetClassInfo();
} else {
cinfo = gInterpreter->ClassInfo_Factory();
}

// ROOT does yet have a complete TType class, but TCling does,
// so let's use that for now.
static TypeInfo_t *const doubletype { gInterpreter->TypeInfo_Factory("double") };

std::vector<TypeInfo_t*> proto(nargs,doubletype);

CallFunc_t *callfunc = gInterpreter->CallFunc_Factory();
Long_t func_offset;
gInterpreter->CallFunc_SetFuncProto(callfunc,cinfo,functionName,proto,false,&func_offset,ROOT::kConversionMatch);

TMethodCall *method = new TMethodCall(ns,callfunc,func_offset);

if (!ns) gInterpreter->ClassInfo_Delete(cinfo);
gInterpreter->CallFunc_Delete(callfunc);

if (method->IsValid()) {
if (method->ReturnType() == TMethodCall::kOther) {
/*
Error("Compile",
"TFormula can only call interpreted and compiled function that returns a numerical type %s returns a %s\n",
method->GetMethodName(), method->GetMethod()->GetReturnTypeName());
*/
err=29;

} else {

// Analyze the arguments
TIter next(&argArr);
TObjString *objstr;
while ( (objstr=(TObjString*)next()) ) {
Analyze(objstr->String(),err,offset);
}

fExpr[fNoper] = method->GetMethod()->GetPrototype();
SetAction(fNoper, kFunctionCall, fFunctions.GetLast()*1000 + nargs);
fNoper++;
return true;
}
}

delete method;
//
// MI change - extended space of functions
// not forward compatible change
//
TString cbase(chaine);
Int_t args_paran = cbase.First("(");
if (args_paran>0){
cbase[args_paran]=0;
}

ROOT::v5::TFormulaPrimitive *prim = ROOT::v5::TFormulaPrimitive::FindFormula(cbase, args_paran>0 ? cbase.Data() + args_paran + 1 : (const char*)0);
if (prim &&   (!IsA()->GetBaseClass("TTreeFormula"))) {
// TO BE DONE ALSO IN TTREFORMULA - temporary fix MI
// Analyze the arguments
TIter next(&argArr);
TObjString *objstr;
while ( (objstr=(TObjString*)next()) ) {
Analyze(objstr->String(),err,offset); if (err) return kFALSE;
}
if (nargs!=prim->fNArguments) {
Error("Compile",        "%s requires %d arguments",
prim->GetName(), prim->fNArguments);
return kFALSE;
}
fExpr[fNoper] = prim->GetName();
if (prim->fType==10){
SetAction(fNoper, kFD1);
}
if (prim->fType==110){
SetAction(fNoper, kFD2);
}
if (prim->fType==1110){
SetAction(fNoper, kFD3);
}
if (prim->fType==-1){
SetAction(fNoper, kFDM);
if (fNpar<prim->fNParameters) fNpar+=prim->fNParameters;
}

fNoper++;
return kTRUE;
}

return kFALSE;
}

//______________________________________________________________________________
void TFormula::Analyze(const char *schain, Int_t &err, Int_t offset)
{
// Analyze a sub-expression in one formula.
//
//   Expressions in one formula are recursively analyzed.
//   Result of analysis is stored in the object tables.
//
//                  Table of function codes and errors
//                  ==================================
//
//   * functions :
//
//     +           1                   pow          20
//     -           2                   sq           21
//     *           3                   sqrt         22
//     /           4                   strstr       23
//     %           5                   min          24
//                                     max          25
//                                     log          30
//     cos         10                  exp          31
//     sin         11                  log10        32
//     tan         12
//     acos        13                  abs          41
//     asin        14                  sign         42
//     atan        15                  int          43
//     atan2       16
//     fmod        17                  rndm         50
//
//     cosh        70                  acosh        73
//     sinh        71                  asinh        74
//     tanh        72                  atanh        75
//
//     expo       100                  gaus        110     gausn  (see note below)
//     expo(0)    100 0                gaus(0)     110 0   gausn(0)
//     expo(1)    100 1                gaus(1)     110 1   gausn(1)
//     xexpo      100 x                xgaus       110 x   xgausn
//     yexpo      101 x                ygaus       111 x   ygausn
//     zexpo      102 x                zgaus       112 x   zgausn
//     xyexpo     105 x                xygaus      115 x   xygausn
//     yexpo(5)   102 5                ygaus(5)    111 5   ygausn(5)
//     xyexpo(2)  105 2                xygaus(2)   115 2   xygausn(2)
//
//     landau      120 x   landaun (see note below)
//     landau(0)   120 0   landaun(0)
//     landau(1)   120 1   landaun(1)
//     xlandau     120 x   xlandaun
//     ylandau     121 x   ylandaun
//     zlandau     122 x   zlandaun
//     xylandau    125 x   xylandaun
//     ylandau(5)  121 5   ylandaun(5)
//     xylandau(2) 125 2   xylandaun(2)
//
//     pol0        130 x               pol1        130 1xx
//     pol0(0)     130 0               pol1(0)     130 100
//     pol0(1)     130 1               pol1(1)     130 101
//     xpol0       130 x               xpol1       130 101
//     ypol0       131 x               ypol1       131 101
//     zpol0       132 x               zpol1       132 1xx
//     ypol0(5)    131 5               ypol1(5)    131 105
//
//     pi          40
//
//     &&          60                  <            64
//     ||          61                  >            65
//     ==          62                  <=           66
//     !=          63                  =>           67
//     !           68
//     ==(string)  76                  &            78
//     !=(string)  77                  |            79
//     <<(shift)   80                  >>(shift)    81
//     ? :         82
//
//   * constants (kConstants) :
//
//    c0  141 1      c1  141 2  etc..
//
//   * strings (kStringConst):
//
//    sX  143 x
//
//   * variables (kFormulaVar) :
//
//     x    144 0      y    144 1      z    144 2      t    144 3
//
//   * parameters :
//
//     [1]        140 1
//     [2]        140 2
//     etc.
//
//   Special cases for normalized gaussian or landau distributions
//   =============================================================
//   the expression "gaus" is a substitute for
//     [0]*exp(-0.5*((x-[1])/[2])**2)
//   to obtain a standard normalized gaussian, use "gausn" instead of "gaus"
//   the expression "gausn" is a substitute for
//     [0]*exp(-0.5*((x-[1])/[2])**2)/(sqrt(2*pi)*[2]))
//   WARNING: gaus and gausn are mutually exclusive in the same expression.
//
//   In the same way the expression "landau" is a substitute for
//     [0]*TMath::Landau(x,[1],[2],kFALSE)
//   to obtain a standard normalized landau, use "landaun" instead of "landau"
//   the expression "landaun" is a substitute for
//     [0]*TMath::Landau(x,[1],[2],kTRUE)
//   WARNING: landau and landaun are mutually exclusive in the same expression.
//
//   Boolean optimization (kBoolOptmize) :
//   =====================================
//
//     Those pseudo operation are used to implement lazy evaluation of
//     && and ||.  When the left hand of the expression if false
//     (respectively true), the evaluation of the right is entirely skipped
//     (since it would not change the value of the expreession).
//
//     &&   142 11 (one operation on right) 142 21 (2 operations on right)
//     ||   142 12 (one operation on right) 142 22 (2 operations on right)
//
//   * functions calls (kFunctionCall) :
//
//    f0 145  0  f1 145  1  etc..
//
//   Errors :
//   ========
//
//     1  : Division By Zero
//     2  : Invalid Floating Point Operation
//     4  : Empty String
//     5  : invalid syntax
//     6  : Too many operators
//     7  : Too many parameters
//    10  : z specified but not x and y
//    11  : z and y specified but not x
//    12  : y specified but not x
//    13  : z and x specified but not y
//    20  : non integer value for parameter number
//    21  : atan2 requires two arguments
//    22  : pow requires two arguments
//    23  : degree of polynomial not specified
//    24  : Degree of polynomial must be positive
//    25  : Degree of polynomial must be less than 20
//    26  : Unknown name
//    27  : Too many constants in expression
//    28  : strstr requires two arguments
//    29  : interpreted or compiled function have to return a numerical type
//    30  : Bad numerical expression
//    31  : Part of the variable exist but some of it is not accessible or useable
//    40  : '(' is expected
//    41  : ')' is expected
//    42  : '[' is expected
//    43  : ']' is expected
//Begin_Html
/*
<img src="gif/analyze.gif">
*/
//End_Html
//
//  Special functions
//  -----------------
//  By default, the formula is assigned fNumber=0. However, the following
//  formula built with simple functions are assigned  fNumber:
//    "gaus"      100  (or gausn)
//    "xygaus"    110
//    "expo"      200
//    "polN"      300+N
//    "landau"    400
//    "xylandau"  410
//  Note that expressions like gaus(0), expo(1) will force fNumber=0
//
//  Warning when deriving a class from TFormula
//  -------------------------------------------
//   If you overload this member function, you also HAVE TO
//   never call the constructor:
//
//     TFormula::TFormula(const char *name,const char *expression)
//
//   and write your own constructor
//
//     MyClass::MyClass(const char *name,const char *expression) : TFormula()
//
//   which has to call the TFormula default constructor and whose implementation
//   should be similar to the implementation of the normal TFormula constructor
//
//   This is necessary because the normal TFormula constructor call indirectly
//   the virtual member functions Analyze, DefaultString, DefaultValue
//   and DefaultVariable.

Int_t valeur,find,n,i,j,k,lchain,nomb,virgule,inter,nest;
valeur=find=n=i=j=k=lchain=nomb=virgule=inter=nest = 0;
Int_t compt,compt2,compt3,compt4;
Bool_t inString;
Double_t vafConst;
ULong_t vafConst2;
Bool_t parenthese;
TString s,chaine_error,chaine1ST;
TString s1,s2,s3,ctemp;

TString chaine = schain;
const TFormula *oldformula;
Int_t modulo,plus,puiss10,puiss10bis,moins,multi,divi,puiss,et,ou,petit,grand,egal,diff,peteg,grdeg,etx,oux,rshift,lshift,tercond,terelse;
char t;
TString slash("/"), escapedSlash("\\/");
Int_t inter2 = 0;
SetNumber(0);
Int_t actionCode,actionParam;
Int_t err_hint = 0;

// Verify correct matching of parenthesis and remove unnecessary parenthesis.
lchain = chaine.Length();
//if (chaine(lchain-2,2) == "^2") chaine = "sq(" + chaine(0,lchain-2) + ")";
parenthese = kTRUE;
lchain = chaine.Length();
while (parenthese && lchain>0 && err==0){
compt  = 0;
compt2 = 0;
inString = false;
lchain = chaine.Length();
if (lchain==0) err=4;
else {
for (i=1; i<=lchain; ++i) {
if (chaine(i-1,1) == "\"") inString = !inString;
if (!inString) {
if (chaine(i-1,1) == "[") compt2++;
if (chaine(i-1,1) == "]") compt2--;
if (chaine(i-1,1) == "(") compt++;
if (chaine(i-1,1) == ")") compt--;
}
if (compt < 0) err = 40; // more open parentheses than close parentheses
if (compt2< 0) err = 42; // more ] than [
if (compt==0 && (i!=lchain || lchain==1)) parenthese = kFALSE;
// if (lchain<3 && chaine(0,1)!="(" && chaine(lchain-1,1)!=")") parenthese = kFALSE;
}
if (compt > 0) err = 41; // more ( than )
if (compt2> 0) err = 43; // more [ than ]
if (parenthese) chaine = chaine(1,lchain-2);
}
} // while parantheses

if (lchain==0) err=4; // empty string
modulo=plus=moins=multi=divi=puiss=et=ou=petit=grand=egal=diff=peteg=grdeg=etx=oux=rshift=lshift=tercond=terelse=0;

// Look for simple operators

if (err==0) {
compt = compt2 = compt3 = compt4 = 0;puiss10=0;puiss10bis = 0;
inString = false;
j = lchain;
Bool_t isdecimal = 1; // indicates whether the left part is decimal.

for (i=1;i<=lchain; i++) {

puiss10=puiss10bis=0;
if (i>2) {
t = chaine[i-3];
isdecimal = isdecimal && (strchr("0123456789.",t)!=0);
if (isdecimal) {
if ( chaine[i-2] == 'e' || chaine[i-2] == 'E' ) puiss10 = 1;
} else if ( strchr("+-/[]()&|><=!*/%^\\",t) ) {
isdecimal = 1; // reset after delimiter
}
}
if (j>2) {
if (chaine[j-2] == 'e' || chaine[j-2] == 'E') {
Bool_t isrightdecimal = 1;

for(k=j-3; k>=0 && isrightdecimal; --k) {
t = chaine[k];
isrightdecimal = isrightdecimal && (strchr("0123456789.",t)!=0);
if (!isrightdecimal) {
if (strchr("+-/[]()&|><=!*/%^\\",t)!=0) {
puiss10bis = 1;
}
}
}
if (k<0 && isrightdecimal)  puiss10bis = 1;
}
}
if (puiss10 && (i<=lchain)) {
t = chaine[i];
puiss10 = (strchr("0123456789.",t)!=0);
}
if (puiss10bis && (j<=lchain)) {
t = chaine[j];
puiss10bis = (strchr("0123456789.",t)!=0);
}

if (chaine(i-1,1) == "\"") inString = !inString;
if (inString) continue;
if (chaine(i-1,1) == "[") compt2++;
if (chaine(i-1,1) == "]") compt2--;
if (chaine(i-1,1) == "(") compt++;
if (chaine(i-1,1) == ")") compt--;
if (chaine(j-1,1) == "[") compt3++;
if (chaine(j-1,1) == "]") compt3--;
if (chaine(j-1,1) == "(") compt4++;
if (chaine(j-1,1) == ")") compt4--;
if (chaine(i-1,2)=="&&" && !inString && compt==0 && compt2==0 && et==0) {et=i;puiss=0;}
if (chaine(i-1,2)=="||" && compt==0 && compt2==0 && ou==0) {puiss10=0; ou=i;}
if (chaine(i-1,1)=="&"  && compt==0 && compt2==0 && etx==0) {etx=i;puiss=0;}
if (chaine(i-1,1)=="|"  && compt==0 && compt2==0 && oux==0) {puiss10=0; oux=i;}
if (chaine(i-1,2)==">>" && compt==0 && compt2==0 && rshift==0) {puiss10=0; rshift=i;}
if (chaine(i-1,1)==">"  && compt==0 && compt2==0 && rshift==0 && grand==0)
{puiss10=0; grand=i;}
if (chaine(i-1,2)=="<<" && compt==0 && compt2==0 && lshift==0) {puiss10=0; lshift=i;}
if (chaine(i-1,1)=="<"  && compt==0 && compt2==0 && lshift==0 && petit==0)
{puiss10=0; petit=i;
// Check whether or not we have a template names! (actually this can
// only happen in TTreeFormula.
for(int ip = i,depth=0; ip < lchain; ++ip) {
char c = chaine(ip);
// The characteres allowed in the template parameter are alpha-numerical characters,
// underscores, comma, <, > and scope operator.
if (isalnum(c) || c=='_' || c==',') continue;
if (c==':' && chaine(ip+1)==':') { ++ip; continue; }
if (c=='<') { ++depth; continue; }
if (c=='>') {
if (depth) { --depth; continue; }
else {
// We reach the end of the template parameter.
petit = 0;
i = ip+1;
break;
}
}
// Character not authorized within a template parameter
break;
}
if (petit==0) {
// We found a template parameter and modified i
continue; // the for(int i ,...)
}
}
if ((chaine(i-1,2)=="<=" || chaine(i-1,2)=="=<") && compt==0 && compt2==0
&& peteg==0) {peteg=i; puiss10=0; petit=0;}
if ((chaine(i-1,2)=="=>" || chaine(i-1,2)==">=") && compt==0 && compt2==0
&& grdeg==0) {puiss10=0; grdeg=i; grand=0;}
if (chaine(i-1,2) == "==" && compt == 0 && compt2 == 0 && egal == 0) {puiss10=0; egal=i;}
if (chaine(i-1,2) == "!=" && compt == 0 && compt2 == 0 && diff == 0) {puiss10=0; diff=i;}
if (i>1 && chaine(i-1,1) == "+" && compt == 0 && compt2 == 0 && puiss10==0) plus=i;
if (chaine(j-1,1) == "-" && chaine(j-2,1) != "*" && chaine(j-2,1) != "/"
&& chaine(j-2,1)!="^" && compt3==0 && compt4==0 && moins==0 && puiss10bis==0) moins=j;
if (chaine(i-1,1)=="%" && compt==0 && compt2==0 && modulo==0) {puiss10=0; modulo=i;}
if (chaine(i-1,1)=="*" && compt==0 && compt2==0 && multi==0)  {puiss10=0; multi=i;}
if (chaine(j-1,1)=="/" && chaine(j-2,1)!="\\"
&& compt4==0 && compt3==0 && divi==0)
{
puiss10=0; divi=j;
}
if (chaine(j-1)=='^' && compt4==0 && compt3==0 && puiss==0) {puiss10=0; puiss=j;}
if (chaine(i-1)=='?' && compt == 0 && compt2 == 0 && tercond == 0) {puiss10=0; tercond=i;}
if (chaine(i-1)==':' && tercond && compt == 0 && compt2 == 0 && terelse == 0) {
if (i>2 && chaine(i-2)!=':' && chaine(i)!=':') {
puiss10=0; terelse=i;
}
}

j--;
}

// If operator found, analyze left and right part of the statement

actionParam = 0;
if (tercond && terelse) {
if (tercond == 1 || terelse == lchain || tercond == (terelse-1) ) {
err = 5;
chaine_error = "?:";
} else {
// Condition
ctemp = chaine(0,tercond-1);
Analyze(ctemp.Data(),err,offset); if (err) return;

fExpr[fNoper] = "?: condition jump";
actionCode = kJumpIf;
actionParam = 0;
SetAction(fNoper,actionCode, actionParam);
Int_t optloc = fNoper++;

// Expression executed if condition is true.
ctemp = chaine(tercond,terelse-tercond-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
actionParam = fNoper; // We want to skip the next instruction ('else jump'), so we set the param to the current cursor and the next instruction will be skip by the ++i in the eval loop
SetAction(optloc, actionCode, actionParam);

fExpr[fNoper] = "?: else jump";
actionCode = kJump;
actionParam = 0;
// Set jump target.
SetAction(fNoper,actionCode, actionParam);
optloc = fNoper++;

// Expression executed if condition is false.
ctemp = chaine(terelse,lchain-terelse);
Analyze(ctemp.Data(),err,offset); if (err) return;
// Set jump target.
actionParam = fNoper - 1; // We need to not skip the next instruction, so we compensate for the ++i in the eval loop
SetAction(optloc, actionCode, actionParam);

if (IsString(optloc-1) != IsString(fNoper-1)) {
err = 45;
chaine_error = "?:";
}
}
} else if (ou != 0) {    //check for ||
if (ou==1 || ou==lchain-1) {
err=5;
chaine_error="||";
}
else {
ctemp = chaine(0,ou-1);
Analyze(ctemp.Data(),err,offset); if (err) return;

fExpr[fNoper] = "|| checkpoint";
actionCode = kBoolOptimize;
actionParam = 2;
SetAction(fNoper,actionCode, actionParam);
Int_t optloc = fNoper++;

ctemp = chaine(ou+1,lchain-ou-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "||";
actionCode = kOr;
SetAction(fNoper,actionCode, 0);

SetAction( optloc, GetAction(optloc), GetActionParam(optloc) + (fNoper-optloc) * 10);
fNoper++;
if (!CheckOperands(optloc-1,fNoper-1,err)) return;
}
} else if (et!=0) {
if (et==1 || et==lchain-1) {
err=5;
chaine_error="&&";
}
else {
ctemp = chaine(0,et-1);
Analyze(ctemp.Data(),err,offset); if (err) return;

fExpr[fNoper] = "&& checkpoint";
actionCode = kBoolOptimize;
actionParam = 1;
SetAction(fNoper,actionCode,actionParam);

Int_t optloc = fNoper++;

ctemp = chaine(et+1,lchain-et-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "&&";
actionCode = kAnd;
SetAction(fNoper,actionCode,0);

SetAction(optloc, GetAction(optloc), GetActionParam(optloc) + (fNoper-optloc) * 10);
fNoper++;
if (!CheckOperands(optloc-1,fNoper-1,err)) return;
}
} else if (oux!=0) {
if (oux==1 || oux==lchain) {
err=5;
chaine_error="|";
}
else {
ctemp = chaine(0,oux-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(oux,lchain-oux);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "|";
actionCode = kBitOr;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else if (etx!=0) {
if (etx==1 || etx==lchain) {
err=5;
chaine_error="&";
}
else {
ctemp = chaine(0,etx-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(etx,lchain-etx);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "&";
actionCode = kBitAnd;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else if (petit != 0) {
if (petit==1 || petit==lchain) {
err=5;
chaine_error="<";
}
else {
ctemp = chaine(0,petit-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(petit,lchain-petit);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "<";
actionCode = kLess;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else if (grand != 0) {
if (grand==1 || grand==lchain) {
err=5;
chaine_error=">";
}
else {
ctemp = chaine(0,grand-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(grand,lchain-grand);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = ">";
actionCode = kGreater;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else if (peteg != 0) {
if (peteg==1 || peteg==lchain-1) {
err=5;
chaine_error="<=";
}
else {
ctemp = chaine(0,peteg-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
ctemp = chaine(peteg+1,lchain-peteg-1);
UInt_t leftopr = fNoper-1;
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "<=";
actionCode = kLessThan;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else if (grdeg != 0) {
if (grdeg==1 || grdeg==lchain-1) {
err=5;
chaine_error="=>";
}
else {
ctemp = chaine(0,grdeg-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(grdeg+1,lchain-grdeg-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = ">=";
actionCode = kGreaterThan;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else if (egal != 0) {
if (egal==1 || egal==lchain-1) {
err=5;
chaine_error="==";
}
else {
ctemp = chaine(0,egal-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
Int_t optloc = fNoper-1;

ctemp = chaine(egal+1,lchain-egal-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "==";
actionCode = kEqual;

Bool_t isstring = IsString(fNoper-1);
if (IsString(optloc) != isstring) {
err = 45;
chaine_error = "==";
} else if (isstring) {
actionCode = kStringEqual;
}
SetAction(fNoper,actionCode,actionParam);
fNoper++;
}
} else if (diff != 0) {
if (diff==1 || diff==lchain-1) {
err=5;
chaine_error = "!=";
}
else {
ctemp = chaine(0,diff-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
Int_t optloc = fNoper-1;

ctemp = chaine(diff+1,lchain-diff-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "!=";
actionCode = kNotEqual;

Bool_t isstring = IsString(fNoper-1);
if (IsString(optloc) != isstring) {
err = 45;
chaine_error = "!=";
} else if (isstring) {
actionCode = kStringNotEqual;
}
SetAction(fNoper,actionCode,actionParam);
fNoper++;
}
} else if (plus != 0) {
if (plus==lchain) {
err=5;
chaine_error = "+";
}
else {
ctemp = chaine(0,plus-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(plus,lchain-plus);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "+";
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else {
if (moins != 0) {
if (moins == 1) {
ctemp = chaine(moins,lchain-moins);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "-";
actionCode = kSignInv;
SetAction(fNoper,actionCode,actionParam);
++fNoper;
if (!CheckOperands(fNoper-1,err)) return;
} else {
if (moins == lchain) {
err=5;
chaine_error = "-";
} else {
ctemp = chaine(0,moins-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(moins,lchain-moins);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "-";
actionCode = kSubstract;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
}
} else if (modulo != 0) {
if (modulo == 1 || modulo == lchain) {
err=5;
chaine_error="%";
} else {
ctemp = chaine(0,modulo-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(modulo,lchain-modulo);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "%";
actionCode = kModulo;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else if (rshift != 0) {
if (rshift == 1 || rshift == lchain) {
err=5;
chaine_error=">>";
} else {
ctemp = chaine(0,rshift-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(rshift+1,lchain-rshift-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = ">>";
actionCode = kRightShift;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else if (lshift != 0) {
if (lshift == 1 || lshift == lchain) {
err=5;
chaine_error=">>";
} else {
ctemp = chaine(0,lshift-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(lshift+1,lchain-lshift-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = ">>";
actionCode = kLeftShift;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else {
if (multi != 0) {
if (multi == 1 || multi == lchain) {
err=5;
chaine_error="*";
}
else {
ctemp = chaine(0,multi-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(multi,lchain-multi);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "*";
actionCode = kMultiply;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else {
if (divi != 0) {
if (divi == 1 || divi == lchain) {
err=5;
chaine_error = "/";
}
else {
ctemp = chaine(0,divi-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(divi,lchain-divi);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "/";
actionCode = kDivide;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else {
if (puiss != 0) {
if (puiss == 1 || puiss == lchain) {
err = 5;
chaine_error = "**";
}
else {
if (chaine(lchain-2,2) == "^2") {
ctemp = "sq(" + chaine(0,lchain-2) + ")";
Analyze(ctemp.Data(),err,offset); if (err) return;
} else {
ctemp = chaine(0,puiss-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(puiss,lchain-puiss);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "^";
actionCode = kpow;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
}
} else {

find=0;

// Check for a numerical expression
{
Bool_t hasDot = kFALSE;
Bool_t isHexa = kFALSE;
Bool_t hasExpo= kFALSE;
if ((chaine(0,2)=="0x")||(chaine(0,2)=="0X")) isHexa=kTRUE;
for (j=0; j<chaine.Length() && err==0; j++) {
t=chaine[j];
if (!isHexa) {
if (j>0 && (chaine(j,1)=="e" || chaine(j,2)=="e+" || chaine(j,2)=="e-" || chaine(j,1)=="E" || chaine(j,2)=="E+" || chaine(j,2)=="E-")) {
if (hasExpo) {
err=26;
chaine_error=chaine;
}
hasExpo = kTRUE;
// The previous implementation allowed a '.' in the exponent.
// That information was ignored (by sscanf), we now make it an error
// hasDot = kFALSE;
hasDot = kTRUE;  // forbid any additional '.'
if (chaine(j,2)=="e+" || chaine(j,2)=="e-" || chaine(j,2)=="E+" || chaine(j,2)=="E-") j++;
}
else {
if (chaine(j,1) == "." && !hasDot) hasDot = kTRUE; // accept only one '.' in the number
else {
// The previous implementation was allowing ANYTHING after the '.' and thus
// made legal code like '2.3 and fpx' and was just silently ignoring the
// 'and fpx'.
if (!strchr("0123456789",t) && (chaine(j,1)!="+" || j!=0)) {
err = 30;
chaine_error=chaine;
}
}
}
}
else {
if (!strchr("0123456789abcdefABCDEF",t) && (j>1)) {
err = 30;
chaine_error=chaine;
}
}
}
if (fNconst >= gMAXCONST) err = 27;
if (!err) {
if (!isHexa) {if (sscanf((const char*)chaine,"%lg",&vafConst) > 0) err = 0; else err =1;}
else {if (sscanf((const char*)chaine,"%lx",&vafConst2) > 0) err = 0; else err=1;
vafConst = (Double_t) vafConst2;}
fExpr[fNoper] = chaine;
k = -1;
for (j=0;j<fNconst;j++) {
if (vafConst == fConst[j] ) k= j;
}
if ( k < 0) {  k = fNconst; fNconst++; fConst[k] = vafConst; }
actionCode = kConstant;
actionParam = k;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
}
if (err==30) err=0;
else find = kTRUE;
}

// Look for an already defined expression

if (find==0) {
{
R__LOCKGUARD2(gROOTMutex);
oldformula = (const TFormula*)gROOT->GetListOfFunctions()->FindObject((const char*)chaine);
}
if (oldformula && strcmp(schain,oldformula->GetTitle())) {
Int_t nprior = fNpar;
Analyze(oldformula->GetExpFormula(),err,fNpar);
// if the oldformula was using a normalized function (gausn or landaun) set also in this one
if (oldformula->IsNormalized()) SetBit(kNormalized);
if (err) return; // changes fNpar
fNpar = nprior;
find=1;
if (!err) {
Int_t npold = oldformula->GetNpar();
fNpar += npold;
for (Int_t ipar=0;ipar<npold;ipar++) {
fParams[ipar+fNpar-npold] = oldformula->GetParameter(ipar);
}
}
}
}
if (find == 0) {

// Check if chaine is a defined variable.
// Note that DefinedVariable can be overloaded

ctemp = chaine;
ctemp.ReplaceAll(escapedSlash, slash);
Int_t action;
k = DefinedVariable(ctemp,action);
if (k==-3) {
err = 1;
} if (k==-2) {
err = 31;
chaine_error = ctemp;
} else if ( k >= 0 ) {
fExpr[fNoper] = ctemp;
actionCode = action;
actionParam = k;
SetAction(fNoper,actionCode,actionParam);
if (action==kDefinedString) fNstring++;
else if (k <kMAXFOUND && !fAlreadyFound.TestBitNumber(k)) {
fNval++;
}
fNoper++;
} else if (chaine(0,1) == "!") {
ctemp = chaine(1,lchain-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "!";
actionCode = kNot;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,1)=="\"" && chaine(chaine.Length()-1,1)=="\"") {
// It is a string !!!
fExpr[fNoper] = chaine(1,chaine.Length()-2);
actionCode = kStringConst;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
} else if (chaine(0,4) == "cos(") {
ctemp = chaine(3,lchain-3);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "cos";
actionCode = kcos;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,4) == "sin(") {
ctemp = chaine(3,lchain-3);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "sin";
actionCode = ksin;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,4) == "tan(") {
ctemp = chaine(3,lchain-3);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "tan";
actionCode = ktan;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,5) == "acos(") {
ctemp = chaine(4,lchain-4);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "acos";
actionCode = kacos;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,5) == "asin(") {
ctemp = chaine(4,lchain-4);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "asin";
actionCode = kasin;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,5) == "atan(") {
ctemp = chaine(4,lchain-4);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "atan";
actionCode = katan;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,5) == "cosh(") {
ctemp = chaine(4,lchain-4);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "cosh";
actionCode = kcosh;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,5) == "sinh(") {
ctemp = chaine(4,lchain-4);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "sinh";
actionCode = ksinh;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,5) == "tanh(") {
ctemp = chaine(4,lchain-4);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "tanh";
actionCode = ktanh;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,6) == "acosh(") {
ctemp = chaine(5,lchain-5);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "acosh";
actionCode = kacosh;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,6) == "asinh(") {
ctemp = chaine(5,lchain-5);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "asinh";
actionCode = kasinh;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,6) == "atanh(") {
ctemp = chaine(5,lchain-5);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "atanh";
actionCode = katanh;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,3) == "sq(") {
ctemp = chaine(2,lchain-2);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "sq";
actionCode = ksq;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,4) == "log(") {
ctemp = chaine(3,lchain-3);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "log";
actionCode = klog;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,6) == "log10(") {
ctemp = chaine(5,lchain-5);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "log10";
actionCode = klog10;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,4) == "exp(") {
ctemp = chaine(3,lchain-3);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "exp";
actionCode = kexp;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,4) == "abs(") {
ctemp = chaine(3,lchain-3);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "abs";
actionCode = kabs;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,5) == "sign(") {
ctemp = chaine(4,lchain-4);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "sign";
actionCode = ksign;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine(0,4) == "int(") {
ctemp = chaine(3,lchain-3);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "int";
actionCode = kint;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
if (!CheckOperands(fNoper-1,err)) return;
} else if (chaine == "rndm" || chaine(0,5) == "rndm(") {
fExpr[fNoper] = "rndm";
actionCode = krndm;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
} else if (chaine(0,5) == "sqrt(") {
ctemp = chaine(4,lchain-4);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "sqrt";
actionCode = ksqrt;
SetAction(fNoper,actionCode,actionParam);
fNoper++;;
if (!CheckOperands(fNoper-1,err)) return;

// Look for an exponential

} else if ( chaine == "expo" || chaine(0,5)=="expo("
|| (lchain==5 && chaine(1,4)=="expo")
|| (lchain==6 && chaine(2,4)=="expo")
|| chaine(1,5)=="expo(" || chaine(2,5)=="expo(" ) {
chaine1ST=chaine;
if (chaine(1,4) == "expo") {
ctemp=chaine(0,1);
if (ctemp=="x") {
inter2=0;
if (fNdim < 1) fNdim = 1; }
else if (ctemp=="y") {
inter2=1;
if (fNdim < 2) fNdim = 2; }
else if (ctemp=="z") {
inter2=2;
if (fNdim < 3) fNdim = 3; }
else if (ctemp=="t") {
inter2=3;
if (fNdim < 4) fNdim = 4; }
else {
err=26; // unknown name;
chaine_error=chaine1ST;
}
chaine=chaine(1,lchain-1);
lchain=chaine.Length();
} else inter2=0;
if (chaine(2,4) == "expo") {
if (chaine(0,2) != "xy") {
err=26; // unknown name
chaine_error=chaine1ST;
}
else {
inter2=5;
if (fNdim < 2) fNdim = 2;
chaine=chaine(2,lchain-2);
lchain=chaine.Length();
}
}
if (lchain == 4) {
if (fNpar>=gMAXPAR) err=7; // too many parameters
if (!err) {
fExpr[fNoper] = chaine1ST;
actionCode = kexpo + inter2;
actionParam = offset;
SetAction(fNoper,actionCode,actionParam);
if (inter2 == 5+offset && fNpar < 3+offset) fNpar = 3+offset;
if (fNpar < 2+offset) fNpar = 2+offset;
if (fNpar>=gMAXPAR) err=7; // too many parameters
if (!err) {
fNoper++;
if (fNdim < 1) fNdim = 1;
if (fNpar == 2) SetNumber(200);
}
}
} else if (chaine(4,1) == "(") {
ctemp = chaine(5,lchain-6);
fExpr[fNoper] = chaine1ST;
for (j=0; j<ctemp.Length(); j++) {
t=ctemp[j];
if (strchr("0123456789",t)==0 && (ctemp(j,1)!="+" || j!=0)) {
err=20;
chaine_error=chaine1ST;
}
}
if (err==0) {
sscanf(ctemp.Data(),"%d",&inter);
if (inter>=0) {
inter += offset;
actionCode = kexpo + inter2;
actionParam = inter;
SetAction(fNoper,actionCode,actionParam);
if (inter2 == 5) inter++;
if (inter+2>fNpar) fNpar = inter+2;
if (fNpar>=gMAXPAR) err=7; // too many parameters
if (!err) fNoper++;
if (fNpar == 2) SetNumber(200);
} else err=20;
} else err = 20; // non integer value for parameter number
} else {
err=26; // unknown name
chaine_error=chaine;
}

// Look for gaus, xgaus,ygaus,xygaus

} else if (chaine=="gaus"
|| (lchain==5 && chaine(1,4)=="gaus")
|| (lchain==6 && chaine(2,4)=="gaus")
|| chaine(0,5)=="gaus(" || chaine(1,5)=="gaus(" || chaine(2,5)=="gaus(") {
chaine1ST=chaine;
if (chaine(1,4) == "gaus") {
ctemp=chaine(0,1);
if (ctemp=="x") {
inter2=0;
if (fNdim < 1) fNdim = 1; }
else if (ctemp=="y") {
inter2=1;
if (fNdim < 2) fNdim = 2; }
else if (ctemp=="z") {
inter2=2;
if (fNdim < 3) fNdim = 3; }
else if (ctemp=="t") {
inter2=3;
if (fNdim < 4) fNdim = 4; }
else {
err=26; // unknown name
chaine_error=chaine1ST;
}
chaine=chaine(1,lchain-1);
lchain=chaine.Length();
} else inter2=0;
if (chaine(2,4) == "gaus") {
if (chaine(0,2) != "xy") {
err=26; // unknown name
chaine_error=chaine1ST;
}
else {
inter2=5;
if (fNdim < 2) fNdim = 2;
chaine=chaine(2,lchain-2);
lchain=chaine.Length();
SetNumber(110); // xygaus
}
}
if (lchain == 4 && err==0) {
if (fNpar>=gMAXPAR) err=7; // too many parameters
if (!err) {
fExpr[fNoper] = chaine1ST;
actionCode = kgaus + inter2;
actionParam = offset;
SetAction(fNoper,actionCode,actionParam);
if (inter2 == 5+offset && fNpar < 5+offset) fNpar = 5+offset;
if (3+offset>fNpar) fNpar = 3+offset;
if (fNpar>=gMAXPAR) err=7; // too many parameters
if (!err) {
fNoper++;
if (fNdim < 1) fNdim = 1;
if (fNpar == 3) SetNumber(100);
}
}
} else if (chaine(4,1) == "(" && err==0) {
ctemp = chaine(5,lchain-6);
fExpr[fNoper] = chaine1ST;
for (j=0; j<ctemp.Length(); j++) {
t=ctemp[j];
if (strchr("0123456789",t)==0 && (ctemp(j,1)!="+" || j!=0)) {
err=20;
chaine_error=chaine1ST;
}
}
if (err==0) {
sscanf(ctemp.Data(),"%d",&inter);
if (inter >= 0) {
inter += offset;
actionCode = kgaus + inter2;
actionParam = inter;
SetAction(fNoper,actionCode,actionParam);
if (inter2 == 5) inter += 2;
if (inter+3>fNpar) fNpar = inter+3;
if (fNpar>=gMAXPAR) err=7; // too many parameters
if (!err) fNoper++;
if(fNpar == 3) SetNumber(100);
} else err = 20; // non integer value for parameter number
}
} else if (err==0) {
err=26; // unknown name
chaine_error=chaine1ST;
}

// Look for landau, xlandau,ylandau,xylandau

} else if (chaine=="landau" || (lchain==7 && chaine(1,6)=="landau")
|| (lchain==8 && chaine(2,6)=="landau")
|| chaine(0,7)=="landau(" || chaine(1,7)=="landau(" || chaine(2,7)=="landau(") {
chaine1ST=chaine;
if (chaine(1,6) == "landau") {
ctemp=chaine(0,1);
if (ctemp=="x") {
inter2=0;
if (fNdim < 1) fNdim = 1; }
else if (ctemp=="y") {
inter2=1;
if (fNdim < 2) fNdim = 2; }
else if (ctemp=="z") {
inter2=2;
if (fNdim < 3) fNdim = 3; }
else if (ctemp=="t") {
inter2=3;
if (fNdim < 4) fNdim = 4; }
else {
err=26; // unknown name
chaine_error=chaine1ST;
}
chaine=chaine(1,lchain-1);
lchain=chaine.Length();
} else inter2=0;
if (chaine(2,6) == "landau") {
if (chaine(0,2) != "xy") {
err=26; // unknown name
chaine_error=chaine1ST;
}
else {
inter2=5;
if (fNdim < 2) fNdim = 2;
chaine=chaine(2,lchain-2);
lchain=chaine.Length();
SetNumber(410);
}
}
if (lchain == 6 && err==0) {
if (fNpar>=gMAXPAR) err=7; // too many parameters
if (!err) {
fExpr[fNoper] = chaine1ST;
actionCode = klandau + inter2;
actionParam = offset;
SetAction(fNoper,actionCode,actionParam);
if (inter2 == 5+offset && fNpar < 5+offset) fNpar = 5+offset;
if (3+offset>fNpar) fNpar = 3+offset;
if (fNpar>=gMAXPAR) err=7; // too many parameters
if (!err) {
fNoper++;
if (fNdim < 1) fNdim = 1;
if (fNpar == 3) SetNumber(400);
}
}
} else if (chaine(6,1) == "(" && err==0) {
ctemp = chaine(7,lchain-8);
fExpr[fNoper] = chaine1ST;
for (j=0; j<ctemp.Length(); j++) {
t=ctemp[j];
if (strchr("0123456789",t)==0 && (ctemp(j,1)!="+" || j!=0)) {
err=20;
chaine_error=chaine1ST;
}
}
if (err==0) {
sscanf(ctemp.Data(),"%d",&inter);
if (inter >= 0) {
inter += offset;
actionCode = klandau + inter2;
actionParam = inter;
SetAction(fNoper,actionCode,actionParam);
if (inter2 == 5) inter += 2;
if (inter+3>fNpar) fNpar = inter+3;
if (fNpar>=gMAXPAR) err=7; // too many parameters
if (!err) fNoper++;
if (fNpar == 3) SetNumber(400);
} else err = 20; // non integer value for parameter number
}
} else if (err==0) {
err=26; // unknown name
chaine_error=chaine1ST;
}

// Look for a polynomial

} else if (chaine(0,3) == "pol" || chaine(1,3) == "pol") {
chaine1ST=chaine;
if (chaine(1,3) == "pol") {
ctemp=chaine(0,1);
if (ctemp=="x") {
inter2=1;
if (fNdim < 1) fNdim = 1; }
else if (ctemp=="y") {
inter2=2;
if (fNdim < 2) fNdim = 2; }
else if (ctemp=="z") {
inter2=3;
if (fNdim < 3) fNdim = 3; }
else if (ctemp=="t") {
inter2=4;
if (fNdim < 4) fNdim = 4; }
else {
err=26; // unknown name;
chaine_error=chaine1ST;
}
chaine=chaine(1,lchain-1);
lchain=chaine.Length();
} else inter2=1;
if (chaine(lchain-1,1) == ")") {
nomb = 0;
for (j=3;j<lchain;j++) if (chaine(j,1)=="(" && nomb == 0) nomb = j;
if (nomb == 3) err = 23; // degree of polynomial not specified
if (nomb == 0) err = 40; // '(' is expected
ctemp = chaine(nomb+1,lchain-nomb-2);
for (j=0; j<ctemp.Length(); j++) {
t=ctemp[j];
if (strchr("0123456789",t)==0 && (ctemp(j,1)!="+" || j!=0)) {
err=20;
chaine_error=chaine1ST;
}
}
if (!err) {
sscanf(ctemp.Data(),"%d",&inter);
if (inter < 0) err = 20;
}
}
else {
nomb = lchain;
inter = 0;
}
if (!err) {
inter--;
ctemp = chaine(3,nomb-3);
if (sscanf(ctemp.Data(),"%d",&n) > 0) {
if (n < 0  ) err = 24; //Degree of polynomial must be positive
if (n >= 20) err = 25; //Degree of polynomial must be less than 20
} else err = 20;
}
if (!err) {
fExpr[fNoper] = chaine1ST;
actionCode = kpol+(inter2-1);
actionParam = n*100+inter+2;
SetAction(fNoper,actionCode,actionParam);
if (inter+n+1>=fNpar) fNpar = inter + n + 2;
if (fNpar>=gMAXPAR) err=7; // too many parameters
if (!err) {
fNoper++;
if (fNdim < 1) fNdim = 1;
SetNumber(300+n);
}
}

// Look for pow,atan2,etc

} else if (chaine(0,4) == "pow(") {
compt = 4; nomb = 0; virgule = 0; nest=0;
while(compt != lchain) {
compt++;
if (chaine(compt-1,1) == "(") nest++;
else if (chaine(compt-1,1) == ")") nest--;
else if (chaine(compt-1,1) == "," && nest==0) {
nomb++;
if (nomb == 1 && virgule == 0) virgule = compt;
}
}
if (nomb != 1) err = 22; // There are plus or minus than 2 arguments for pow
else {
ctemp = chaine(4,virgule-5);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(virgule,lchain-virgule-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "^";
actionCode = kpow;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else if (chaine(0,7) == "strstr(") {
compt = 7; nomb = 0; virgule = 0; nest=0;
inString = false;
while(compt != lchain) {
compt++;
if (chaine(compt-1,1) == "\"") {
inString = !inString;
}  else if (!inString) {
if (chaine(compt-1,1) == "(") nest++;
else if (chaine(compt-1,1) == ")") nest--;
else if (chaine(compt-1,1) == "," && nest==0) {
nomb++;
if (nomb == 1 && virgule == 0) virgule = compt;
}
}
}
if (nomb != 1) err = 28; // There are plus or minus than 2 arguments for strstr
else {
ctemp = chaine(7,virgule-8);
Analyze(ctemp.Data(),err,offset); if (err) return;
Int_t optloc = fNoper-1;

ctemp = chaine(virgule,lchain-virgule-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "strstr";
actionCode = kstrstr;
SetAction(fNoper,actionCode,actionParam);
fNoper++;

if ( !IsString(optloc) || !IsString(fNoper-2) ) {
err = 46;
chaine_error = "strstr";
}
}
} else if (chaine(0,4) == "min(") {
compt = 4; nomb = 0; virgule = 0; nest=0;
while(compt != lchain) {
compt++;
if (chaine(compt-1,1) == "(") nest++;
else if (chaine(compt-1,1) == ")") nest--;
else if (chaine(compt-1,1) == "," && nest==0) {
nomb++;
if (nomb == 1 && virgule == 0) virgule = compt;
}
}
if (nomb != 1) {
err = 44; // There are plus or minus than 2 arguments for min
err_hint = 3;
}
else {
ctemp = chaine(4,virgule-5);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(virgule,lchain-virgule-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "min";
actionCode = kmin;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else if (chaine(0,4) == "max(") {
compt = 4; nomb = 0; virgule = 0; nest=0;
while(compt != lchain) {
compt++;
if (chaine(compt-1,1) == "(") nest++;
else if (chaine(compt-1,1) == ")") nest--;
else if (chaine(compt-1,1) == "," && nest==0) {
nomb++;
if (nomb == 1 && virgule == 0) virgule = compt;
}
}
if (nomb != 1) {
err = 44; // There are plus or minus than 2 arguments for min
err_hint = 3;
}
else {
ctemp = chaine(4,virgule-5);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(virgule,lchain-virgule-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "max";
actionCode = kmax;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}

} else if (chaine(0,6) == "atan2(") {
compt = 6; nomb = 0; virgule = 0; nest=0;
while(compt != lchain) {
compt++;
if (chaine(compt-1,1) == "(") nest++;
else if (chaine(compt-1,1) == ")") nest--;
else if (chaine(compt-1,1) == "," && nest==0) {
nomb++;
if (nomb == 1 && virgule == 0) virgule = compt;
}
}
if (nomb != 1) err = 21;  //{ There are plus or minus than 2 arguments for atan2
else {
ctemp = chaine(6,virgule-7);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(virgule,lchain-virgule-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "atan2";
actionCode = katan2;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else if (chaine(0,5) == "fmod(") {
compt = 5; nomb = 0; virgule = 0; nest=0;
while(compt != lchain) {
compt++;
if (chaine(compt-1,1) == "(") nest++;
else if (chaine(compt-1,1) == ")") nest--;
else if (chaine(compt-1,1) == "," && nest==0) {
nomb++;
if (nomb == 1 && virgule == 0) virgule = compt;
}
}
if (nomb != 1) {
err = 44; // There are plus or minus than 2 arguments for fmod
err_hint = 4;
}
else {
ctemp = chaine(5,virgule-6);
Analyze(ctemp.Data(),err,offset); if (err) return;
UInt_t leftopr = fNoper-1;
ctemp = chaine(virgule,lchain-virgule-1);
Analyze(ctemp.Data(),err,offset); if (err) return;
fExpr[fNoper] = "fmod";
actionCode = kfmod;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
if (!CheckOperands(leftopr,fNoper-1,err)) return;
}
} else if (AnalyzeFunction(chaine,err,offset) || err) { // The '||err' is to grab an error coming from AnalyzeFunction
if (err) {
chaine_error = chaine;
} else {
// We have a function call. Note that all the work was already,
// eventually done in AnalyzeFunction
//fprintf(stderr,"We found a foreign function in %s\n",chaine.Data());
}
} else if (chaine(0,1) == "[" && chaine(lchain-1,1) == "]") {
fExpr[fNoper] = chaine;
fNoper++;
ctemp = chaine(1,lchain-2);
for (j=0; j<ctemp.Length(); j++) {
t=ctemp[j];
if (strchr("0123456789",t)==0 && (ctemp(j,1)!="+" || j!=0)) {
err=20;
chaine_error=chaine1ST; // le numero ? de par[?] n'est pas un entier }
}
}
if (!err) {
sscanf(ctemp.Data(),"%d",&valeur);
actionCode = kParameter;
actionParam = offset + valeur;
SetAction(fNoper-1, actionCode, actionParam);
fExpr[fNoper-1] = "[";
fExpr[fNoper-1] = (fExpr[fNoper-1] + (long int)(valeur+offset)) + "]";
}
} else if (chaine == "pi") {
fExpr[fNoper] = "pi";
actionCode = kpi;
SetAction(fNoper,actionCode,actionParam);
fNoper++;
}
else {

// None of the above.

err = 30;
}
}
}
}
}
}
}

// Overflows
if (fNoper>=gMAXOP) err=6; // too many operators

}

// errors!
if (err>1) {
TString er = "";
chaine_error = "\""+chaine_error+"\"";
switch(err) {
case  2 : er = " Invalid Floating Point Operation"; break;
case  4 : er = " Empty String"; break;
case  5 : er = " Invalid Syntax " + chaine_error; break;
case  6 : er = " Too many operators !"; break;
case  7 : er = " Too many parameters !"; break;
case 10 : er = " z specified but not x and y"; break;
case 11 : er = " z and y specified but not x"; break;
case 12 : er = " y specified but not x"; break;
case 13 : er = " z and x specified but not y"; break;
case 20 : er = " Non integer value for parameter number : " + chaine_error; break;
case 21 : er = " ATAN2 requires two arguments"; break;
case 22 : er = " POW requires two arguments"; break;
case 23 : er = " Degree of polynomial not specified"; break;
case 24 : er = " Degree of polynomial must be positive"; break;
case 25 : er = " Degree of polynomial must be less than 20"; break;
case 26 : er = " Unknown name : " + chaine_error; break;
case 27 : er = " Too many constants in expression"; break;
case 28 : er = " strstr requires two arguments"; break;
case 29 : er = " TFormula can only call interpreted and compiled functions that return a numerical type: " + chaine_error; break;
case 30 : er = " Bad numerical expression : " + chaine_error; break;
case 31 : er = " Part of the Variable " + chaine_error; er += " exists but some of it is not accessible or useable"; break;
case 40 : er = " '(' is expected"; break;
case 41 : er = " ')' is expected"; break;
case 42 : er = " '[' is expected"; break;
case 43 : er = " ']' is expected"; break;
case 44 : er = " The function '" + chaine(0,err_hint) + "' requires two arguments."; break;
case 45 : er = "The operator " + chaine_error + " requires a numerical operand."; break;
case 46 : er = "Both operands of the operator " + chaine_error + " have to be either numbers or strings."; break;
case 47 : er = chaine_error + " requires 2 string arguments"; break;
}
Error("Compile", "%s", er.Data());
err=1;
}

}

//______________________________________________________________________________
Bool_t TFormula::CheckOperands(Int_t oper, Int_t &err)
{
// Check whether the operand at 'oper-1' is compatible with the operation
// at 'oper'.

if ( IsString(oper-1) && !StringToNumber(oper-1) ) {
Error("Compile","\"%s\" requires a numerical operand.",fExpr[oper].Data());
err = 45;
return kFALSE;
}
return kTRUE;
}

//______________________________________________________________________________
Bool_t TFormula::CheckOperands(Int_t leftoper, Int_t oper, Int_t &err)
{
// Check whether the operands at 'leftoper' and 'oper-1' are compatible with
// the operation at 'oper'.

if ( IsString(oper-1) || IsString(leftoper) ) {
if (IsString(oper-1) && StringToNumber(oper-1)) {
return kTRUE;
}
if (IsString(leftoper) && StringToNumber(leftoper)) {
return kTRUE;
}
Error("Compile","\"%s\" requires two numerical operands.",fExpr[oper].Data());
err = 46;
return kFALSE;
}
return kTRUE;
}

//______________________________________________________________________________
Bool_t TFormula::StringToNumber(Int_t /* code */)
{
// Try to 'demote' a string into an array bytes.  If this is not possible,
// return false.

// In TFormula proper, we can not handle array of bytes ...
return kFALSE;
}

//______________________________________________________________________________
void TFormula::Clear(Option_t * /*option*/ )
{
// Resets the objects.
//
// Resets the object to its state before compilation.

ClearFormula();
}

//______________________________________________________________________________
void TFormula::ClearFormula(Option_t * /*option*/ )
{
// Resets the objects.
//
// Resets the object to its state before compilation.

fNdim   = 0;
fNpar   = 0;
fNoper  = 0;
fNconst = 0;
fNumber = 0;
fNstring= 0;
fNval   = 0;

if (fExpr)   { delete [] fExpr;   fExpr   = 0;}
if (fNames)  { delete [] fNames;  fNames  = 0;}
if (fOper)   { delete [] fOper;   fOper   = 0;}
if (fConst)  { delete [] fConst;  fConst  = 0;}
if (fParams) { delete [] fParams; fParams = 0;}
fFunctions.Delete();
fLinearParts.Delete();
//
//MI change
if (fPredefined)    { delete [] fPredefined;    fPredefined    = 0;}
if (fOperOffset)    { delete [] fOperOffset;    fOperOffset    = 0;}
if (fExprOptimized) { delete [] fExprOptimized; fExprOptimized = 0;}
if (fOperOptimized) { delete [] fOperOptimized; fOperOptimized = 0;}
// should we also remove the object from the list?
// gROOT->GetListOfFunctions()->Remove(this);
// if we don't, what happens if it fails the new compilation?
}

namespace {
template <class T>
inline static void ResizeArrayIfAllocated(T*& oldArray, int newSize){

// Don't do anything in this case.
if (!oldArray || newSize <=0) return;

T* newArray = new T[newSize];
std::copy(oldArray, oldArray+newSize, newArray);
delete [] oldArray;
oldArray = newArray;
}
}

//______________________________________________________________________________
Int_t TFormula::Compile(const char *expression)
{
// Compile expression already stored in fTitle.
//
//   Loop on all subexpressions of formula stored in fTitle
//
//   If you overload this member function, you also HAVE TO
//   never call the constructor:
//
//     TFormula::TFormula(const char *name,const char *expression)
//
//   and write your own constructor
//
//     MyClass::MyClass(const char *name,const char *expression) : TFormula()
//
//   which has to call the TFormula default constructor and whose implementation
//   should be similar to the implementation of the normal TFormula constructor
//
//   This is necessary because the normal TFormula constructor call indirectly
//   the virtual member functions Analyze, DefaultString, DefaultValue
//   and DefaultVariable.
//
//Begin_Html
/*
<img src="gif/compile.gif">
*/
//End_Html

Int_t i,j,lc,valeur,err;
TString ctemp;

ClearFormula();

// If expression is not empty, take it, otherwise take the title
if (strlen(expression)) SetTitle(expression);

TString chaine = GetTitle();

if (chaine.Contains(";")) {
char *sctemp = new char[chaine.Length()+1];
strlcpy(sctemp,chaine.Data(),chaine.Length()+1);
char *semicol = (char*)strstr(sctemp,";");
if (semicol) *semicol = 0;
chaine = sctemp;
delete [] sctemp;
}

// if the function is linear, process it and fill the array of linear parts
if (TestBit(kLinear)){
ProcessLinear(chaine);
}

// see static function SetMaxima to change the gMAX.. default values
fExpr   = new TString[gMAXOP];
fConst  = new Double_t[gMAXCONST];
fParams = new Double_t[gMAXPAR];
fNames  = new TString[gMAXPAR];
fOper   = new Int_t[gMAXOP];
for (i=0; i<gMAXPAR; i++) {
fParams[i] = 0;
fNames[i] = "";
}
for (i=0; i<gMAXOP; i++) {
fExpr[i] = "";
fOper[i] = 0;
}
for (i=0; i<gMAXCONST; i++)
fConst[i] = 0;

// Substitution of some operators to C++ style
Bool_t inString = false;
for (i=1; i<=chaine.Length(); i++) {
lc =chaine.Length();
if (chaine(i-1,1) == "\"") inString = !inString;
if (inString) continue;
if (chaine(i-1,2) == "**") {
chaine = chaine(0,i-1) + "^" + chaine(i+1,lc-i-1);
i=0;
} else if (chaine(i-1,2) == "++") {
chaine = chaine(0,i) + chaine(i+1,lc-i-1);
i=0;
} else if (chaine(i-1,2) == "+-" || chaine(i-1,2) == "-+") {
chaine = chaine(0,i-1) + "-" + chaine(i+1,lc-i-1);
i=0;
} else if (chaine(i-1,2) == "--") {
chaine = chaine(0,i-1) + "+" + chaine(i+1,lc-i-1);
i=0;
} else if (chaine(i-1,2) == "->") {
chaine = chaine(0,i-1) + "." + chaine(i+1,lc-i-1);
i=0;
} else if (chaine(i-1,1) == "[") {
for (j=1;j<=chaine.Length()-i;j++) {
if (chaine(j+i-1,1) == "]" || j+i > chaine.Length()) break;
}
ctemp = chaine(i,j-1);
valeur=0;
sscanf(ctemp.Data(),"%d",&valeur);
if (valeur >= fNpar) fNpar = valeur+1;
} else if (chaine(i-1,1) == " ") {
chaine = chaine(0,i-1)+chaine(i,lc-i);
i=0;
}
}
err = 0;
Analyze((const char*)chaine,err);

// if no parameters delete arrays fParams and fNames
if (!fNpar) {
delete [] fParams; fParams = 0;
delete [] fNames;  fNames = 0;
}

// if no errors, copy local parameters to formula objects
if (!err) {
if (fNdim <= 0) fNdim = 1;
if (chaine.Length() > 4)
{
if ( GetNumber() != 400 &&
GetNumber() != 410 &&
GetNumber() != 110 )
SetNumber(0);
else if ( GetNumber() == 110 && chaine.Length() > 6 )
SetNumber(0);
else if ( GetNumber() == 410 && chaine.Length() > 8 )
SetNumber(0);
}
// if formula is a gaussian, set parameter names
if (GetNumber() == 100) {
SetParName(0,"Constant");
SetParName(1,"Mean");
SetParName(2,"Sigma");
}
// if formula is a 2D gaussian, set parameter names
if (GetNumber() == 110){
SetParName(0,"Constant");
SetParName(1,"MeanX");
SetParName(2,"SigmaX");
SetParName(3,"MeanY");
SetParName(4,"SigmaY");
}
// if formula is an exponential, set parameter names
if (GetNumber() == 200) {
SetParName(0,"Constant");
SetParName(1,"Slope");
}
// if formula is a polynome, set parameter names
if (GetNumber() == 300+fNpar) {
for (i=0;i<fNpar;i++) SetParName(i,Form("p%d",i));
}
// if formula is a landau, set parameter names
if (GetNumber() == 400) {
SetParName(0,"Constant");
SetParName(1,"MPV");
SetParName(2,"Sigma");
}
// if formula is a 2D landau, set parameter names
if (GetNumber() == 410) {
SetParName(0,"Constant");
SetParName(1,"MPVX");
SetParName(2,"SigmaX");
SetParName(3,"MPVY");
SetParName(4,"SigmaY");
}
}

// Here we shrink the arrays allocated like this:
//    fExpr   = new TString[gMAXOP];
//    fConst  = new Double_t[gMAXCONST];
//    fParams = new Double_t[gMAXPAR];
//    fNames  = new TString[gMAXPAR];
//    fOper   = new Int_t[gMAXOP];
// fParams and fNames may be already 0, so we have to check.
if (!err){
ResizeArrayIfAllocated(fExpr, fNoper);
ResizeArrayIfAllocated(fConst, fNconst);
ResizeArrayIfAllocated(fParams, fNpar);
ResizeArrayIfAllocated(fNames, fNpar);
ResizeArrayIfAllocated(fOper, fNoper);
}

if (err) { fNdim = 0; return 1; }
//   Convert(5);
//
//MI change
if (!IsA()->GetBaseClass("TTreeFormula")) {
Optimize();
}
//
return 0;
}

//______________________________________________________________________________
void TFormula::Copy(TObject &obj) const
{
// Copy this formula.

Int_t i;
((TFormula&)obj).ClearFormula();
TNamed::Copy(obj);
((TFormula&)obj).fNdim   = fNdim;
((TFormula&)obj).fNpar   = fNpar;
((TFormula&)obj).fNoper  = fNoper;
((TFormula&)obj).fNconst = fNconst;
((TFormula&)obj).fNumber = fNumber;
((TFormula&)obj).fNval   = fNval;
((TFormula&)obj).fExpr   = 0;
((TFormula&)obj).fConst  = 0;
((TFormula&)obj).fParams = 0;
((TFormula&)obj).fNames  = 0;
if (fExpr && fNoper) {
((TFormula&)obj).fExpr = new TString[fNoper];
for (i=0;i<fNoper;i++)  ((TFormula&)obj).fExpr[i]   = fExpr[i];
}
if (fOper && fNoper) {
((TFormula&)obj).fOper = new Int_t[fNoper];
for (i=0;i<fNoper;i++)  ((TFormula&)obj).fOper[i]   = fOper[i];
}
if (fConst && fNconst) {
((TFormula&)obj).fConst = new Double_t[fNconst];
for (i=0;i<fNconst;i++) ((TFormula&)obj).fConst[i]  = fConst[i];
}
if (fParams && fNpar) {
((TFormula&)obj).fParams = new Double_t[fNpar];
for (i=0;i<fNpar;i++)   ((TFormula&)obj).fParams[i] = fParams[i];
}
if (fNames && fNpar) {
((TFormula&)obj).fNames = new TString[fNpar];
for (i=0;i<fNpar;i++)   ((TFormula&)obj).fNames[i]  = fNames[i];
}

TIter next(&fFunctions);
TObject *fobj;
while ( (fobj = next()) ) {
}
//
// MI change
//
//
if (fNoper) {
if(fExprOptimized) {
((TFormula&)obj).fExprOptimized   = new TString[fNoper];
for (i=0;i<fNoper;i++)  ((TFormula&)obj).fExprOptimized[i]   = fExprOptimized[i];
}
if (fOperOptimized) {
((TFormula&)obj).fOperOptimized   = new Int_t[fNoper];
for (i=0;i<fNoper;i++)  ((TFormula&)obj).fOperOptimized[i]   = fOperOptimized[i];
}
if (fPredefined) {
((TFormula&)obj).fPredefined      = new ROOT::v5::TFormulaPrimitive*[fNoper];
for (i=0;i<fNoper;i++) {((TFormula&)obj).fPredefined[i] = fPredefined[i];}
}
if (fOperOffset) {
((TFormula&)obj).fOperOffset         = new TOperOffset[fNoper];
for (i=0;i<fNoper;i++) {((TFormula&)obj).fOperOffset[i] = fOperOffset[i];}
}
}
((TFormula&)obj).fNOperOptimized = fNOperOptimized;
((TFormula&)obj).fOptimal = fOptimal;

}

//______________________________________________________________________________
char *TFormula::DefinedString(Int_t)
{
// Return address of string corresponding to special code.
//
//   This member function is inactive in the TFormula class.
//   It may be redefined in derived classes.
//
//   If you overload this member function, you also HAVE TO
//   never call the constructor:
//
//     TFormula::TFormula(const char *name,const char *expression)
//
//   and write your own constructor
//
//     MyClass::MyClass(const char *name,const char *expression) : TFormula()
//
//   which has to call the TFormula default constructor and whose implementation
//   should be similar to the implementation of the normal TFormula constructor
//
//   This is necessary because the normal TFormula constructor call indirectly
//   the virtual member functions Analyze, DefaultString, DefaultValue
//   and DefaultVariable.

return 0;
}

//______________________________________________________________________________
Double_t TFormula::DefinedValue(Int_t)
{
// Return value corresponding to special code.
//
//   This member function is inactive in the TFormula class.
//   It may be redefined in derived classes.
//
//   If you overload this member function, you also HAVE TO
//   never call the constructor:
//
//     TFormula::TFormula(const char *name,const char *expression)
//
//   and write your own constructor
//
//     MyClass::MyClass(const char *name,const char *expression) : TFormula()
//
//   which has to call the TFormula default constructor and whose implementation
//   should be similar to the implementation of the normal TFormula constructor
//
//   This is necessary because the normal TFormula constructor call indirectly
//   the virtual member functions Analyze, DefaultString, DefaultValue
//   and DefaultVariable.

return 0;
}

//______________________________________________________________________________
Int_t TFormula::DefinedVariable(TString &chaine,Int_t &action)
{
// Check if expression is in the list of defined variables.
//
//   This member function can be overloaded in derived classes
//
//   If you overload this member function, you also HAVE TO
//   never call the constructor:
//
//     TFormula::TFormula(const char *name,const char *expression)
//
//   and write your own constructor
//
//     MyClass::MyClass(const char *name,const char *expression) : TFormula()
//
//   which has to call the TFormula default constructor and whose implementation
//   should be similar to the implementation of the normal TFormula constructor
//
//   This is necessary because the normal TFormula constructor call indirectly
//   the virtual member functions Analyze, DefaultString, DefaultValue
//   and DefaultVariable.
//
//   The expected returns values are
//     -2 :  the name has been recognized but won't be usable
//     -1 :  the name has not been recognized
//    >=0 :  the name has been recognized, return the action parameter.

action = kVariable;
if (chaine == "x") {
if (fNdim < 1) fNdim = 1;
return 0;
} else if (chaine == "y") {
if (fNdim < 2) fNdim = 2;
return 1;
} else if (chaine == "z") {
if (fNdim < 3) fNdim = 3;
return 2;
} else if (chaine == "t") {
if (fNdim < 4) fNdim = 4;
return 3;
}
// MI change
// extended defined variable (MI)
//
if (chaine.Data()[0]=='x'){
if (chaine.Data()[1]=='[' && chaine.Data()[3]==']'){
const char ch0 = '0';
Int_t dim = chaine.Data()[2]-ch0;
if (dim<0) return -1;
if (dim>9) return -1;
if (fNdim<=dim) fNdim = dim+1;
return dim;
}
if (chaine.Data()[1]=='[' && chaine.Data()[4]==']'){
const char ch0 = '0';
Int_t dim = (chaine.Data()[2]-ch0)*10+(chaine.Data()[3]-ch0);
if (dim<0) return -1;
if (dim>99) return -1;
if (fNdim<=dim) fNdim = dim+1;
return dim;
}
}
return -1;
}

//______________________________________________________________________________
Double_t TFormula::Eval(Double_t x, Double_t y, Double_t z, Double_t t) const
{
// Evaluate this formula.
//
//   The current value of variables x,y,z,t is passed through x, y, z and t.
//   The parameters used will be the ones in the array params if params is given
//    otherwise parameters will be taken from the stored data members fParams

Double_t xx[4];
xx[0] = x;
xx[1] = y;
xx[2] = z;
xx[3] = t;
return ((TFormula*)this)->EvalPar(xx);
}

//______________________________________________________________________________
Double_t TFormula::EvalParOld(const Double_t *x, const Double_t *uparams)
{
// Evaluate this formula.
//
//   The current value of variables x,y,z,t is passed through the pointer x.
//   The parameters used will be the ones in the array params if params is given
//    otherwise parameters will be taken from the stored data members fParams
//Begin_Html
/*
<img src="gif/eval.gif">
*/
//End_Html

Int_t i,j;
// coverity[uninit] the tab value of tab is guaranteed to be set properly by the control flow.
Double_t tab[kMAXFOUND];
const char *stringStack[gMAXSTRINGFOUND];
Double_t param_calc[kMAXFOUND];
char *string_calc[gMAXSTRINGFOUND];
Int_t precalculated = 0;
Int_t precalculated_str = 0;
Double_t *params;

if (uparams) {
params = const_cast<Double_t*>(uparams);
} else {
params = fParams;
}
UInt_t pos    = 0;
UInt_t strpos = 0;

for (i=0; i<fNoper; ++i) {

const int oper = fOper[i];
const int opcode = oper >> kTFOperShift;

switch(opcode) {

case kParameter  : { pos++; tab[pos-1] = params[ oper & kTFOperMask ]; continue; }
case kConstant   : { pos++; tab[pos-1] = fConst[ oper & kTFOperMask ]; continue; }
case kVariable   : { pos++; tab[pos-1] = x[ oper & kTFOperMask ]; continue; }
case kStringConst: { strpos++; stringStack[strpos-1] = (char*)fExpr[i].Data(); pos++; tab[pos-1] = 0; continue; }

case kAdd        : pos--; tab[pos-1] += tab[pos]; continue;
case kSubstract  : pos--; tab[pos-1] -= tab[pos]; continue;
case kMultiply   : pos--; tab[pos-1] *= tab[pos]; continue;
case kDivide     : pos--; if (tab[pos] == 0) tab[pos-1] = 0; //  division by 0
else               tab[pos-1] /= tab[pos];
continue;
case kModulo     : {pos--;
Long64_t int1((Long64_t)tab[pos-1]);
Long64_t int2((Long64_t)tab[pos]);
tab[pos-1] = Double_t(int1%int2);
continue;}

case kcos  : tab[pos-1] = TMath::Cos(tab[pos-1]); continue;
case ksin  : tab[pos-1] = TMath::Sin(tab[pos-1]); continue;
case ktan  : if (TMath::Cos(tab[pos-1]) == 0) {tab[pos-1] = 0;} // { tangente indeterminee }
else tab[pos-1] = TMath::Tan(tab[pos-1]);
continue;
case kacos : if (TMath::Abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} //  indetermination
else tab[pos-1] = TMath::ACos(tab[pos-1]);
continue;
case kasin : if (TMath::Abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} //  indetermination
else tab[pos-1] = TMath::ASin(tab[pos-1]);
continue;
case katan : tab[pos-1] = TMath::ATan(tab[pos-1]); continue;
case kcosh : tab[pos-1] = TMath::CosH(tab[pos-1]); continue;
case ksinh : tab[pos-1] = TMath::SinH(tab[pos-1]); continue;
case ktanh : if (TMath::CosH(tab[pos-1]) == 0) {tab[pos-1] = 0;} // { tangente indeterminee }
else tab[pos-1] = TMath::TanH(tab[pos-1]);
continue;
case kacosh: if (tab[pos-1] < 1) {tab[pos-1] = 0;} //  indetermination
else tab[pos-1] = TMath::ACosH(tab[pos-1]);
continue;
case kasinh: tab[pos-1] = TMath::ASinH(tab[pos-1]); continue;
case katanh: if (TMath::Abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} // indetermination
else tab[pos-1] = TMath::ATanH(tab[pos-1]); continue;
case katan2: pos--; tab[pos-1] = TMath::ATan2(tab[pos-1],tab[pos]); continue;

case kfmod : pos--; tab[pos-1] = fmod(tab[pos-1],tab[pos]); continue;
case kpow  : pos--; tab[pos-1] = TMath::Power(tab[pos-1],tab[pos]); continue;
case ksq   : tab[pos-1] = tab[pos-1]*tab[pos-1]; continue;
case ksqrt : tab[pos-1] = TMath::Sqrt(TMath::Abs(tab[pos-1])); continue;

case kstrstr : strpos -= 2; pos-=2; pos++;
if (strstr(stringStack[strpos],stringStack[strpos+1])) tab[pos-1]=1;
else tab[pos-1]=0; continue;

case kmin : pos--; tab[pos-1] = TMath::Min(tab[pos-1],tab[pos]); continue;
case kmax : pos--; tab[pos-1] = TMath::Max(tab[pos-1],tab[pos]); continue;

case klog  : if (tab[pos-1] > 0) tab[pos-1] = TMath::Log(tab[pos-1]);
else {tab[pos-1] = 0;} //{indetermination }
continue;
case kexp  : { Double_t dexp = tab[pos-1];
if (dexp < -700) {tab[pos-1] = 0; continue;}
if (dexp >  700) {tab[pos-1] = TMath::Exp(700); continue;}
tab[pos-1] = TMath::Exp(dexp); continue;  }
case klog10: if (tab[pos-1] > 0) tab[pos-1] = TMath::Log10(tab[pos-1]);
else {tab[pos-1] = 0;} //{indetermination }
continue;

case kpi   : pos++; tab[pos-1] = TMath::ACos(-1); continue;

case kabs  : tab[pos-1] = TMath::Abs(tab[pos-1]); continue;
case ksign : if (tab[pos-1] < 0) tab[pos-1] = -1; else tab[pos-1] = 1; continue;
case kint  : tab[pos-1] = Double_t(Int_t(tab[pos-1])); continue;

case kSignInv: tab[pos-1] = -1 * tab[pos-1]; continue;

case krndm : pos++; tab[pos-1] = gRandom->Rndm(1); continue;

case kAnd  : pos--; if (tab[pos-1]!=0 && tab[pos]!=0) tab[pos-1]=1;
else tab[pos-1]=0; continue;
case kOr   : pos--; if (tab[pos-1]!=0 || tab[pos]!=0) tab[pos-1]=1;
else tab[pos-1]=0; continue;
case kEqual: pos--; if (tab[pos-1] == tab[pos]) tab[pos-1]=1;
else tab[pos-1]=0; continue;
case kNotEqual : pos--; if (tab[pos-1] != tab[pos]) tab[pos-1]=1;
else tab[pos-1]=0; continue;
case kLess     : pos--; if (tab[pos-1] < tab[pos]) tab[pos-1]=1;
else tab[pos-1]=0; continue;
case kGreater  : pos--; if (tab[pos-1] > tab[pos]) tab[pos-1]=1;
else tab[pos-1]=0; continue;

case kLessThan: pos--; if (tab[pos-1]<=tab[pos]) tab[pos-1]=1;
else tab[pos-1]=0; continue;
case kGreaterThan: pos--; if (tab[pos-1]>=tab[pos]) tab[pos-1]=1;
else tab[pos-1]=0; continue;
case kNot : if (tab[pos-1]!=0) tab[pos-1] = 0; else tab[pos-1] = 1; continue;

case kStringEqual : strpos -= 2; pos -=2 ; pos++;
if (!strcmp(stringStack[strpos+1],stringStack[strpos])) tab[pos-1]=1;
else tab[pos-1]=0; continue;
case kStringNotEqual: strpos -= 2; pos -= 2; pos++;
if (strcmp(stringStack[strpos+1],stringStack[strpos])) tab[pos-1]=1;
else tab[pos-1]=0; continue;

case kBitAnd : pos--; tab[pos-1]= ((Int_t) tab[pos-1]) & ((Int_t) tab[pos]); continue;
case kBitOr  : pos--; tab[pos-1]= ((Int_t) tab[pos-1]) | ((Int_t) tab[pos]); continue;
case kLeftShift : pos--; tab[pos-1]= ((Int_t) tab[pos-1]) <<((Int_t) tab[pos]); continue;
case kRightShift: pos--; tab[pos-1]= ((Int_t) tab[pos-1]) >>((Int_t) tab[pos]); continue;

case kJump   : i = (oper & kTFOperMask); continue;
case kJumpIf : pos--; if (!tab[pos]) i = (oper & kTFOperMask); continue;

case kBoolOptimize: {
// boolean operation optimizer

int param = (oper & kTFOperMask);
Bool_t skip = kFALSE;
int op = param % 10; // 1 is && , 2 is ||

if (op == 1 && (!tab[pos-1]) ) {
// &&: skip the right part if the left part is already false

skip = kTRUE;

// Preserve the existing behavior (i.e. the result of a&&b is
// either 0 or 1)
tab[pos-1] = 0;

} else if (op == 2 && tab[pos-1] ) {
// ||: skip the right part if the left part is already true

skip = kTRUE;

// Preserve the existing behavior (i.e. the result of a||b is
// either 0 or 1)
tab[pos-1] = 1;

}

if (skip) {
int toskip = param / 10;
i += toskip;
}
continue;
}

}

switch(opcode) {

#define R__EXPO(var)                                                 \
{                                                                    \
pos++; int param = (oper & kTFOperMask);                          \
tab[pos-1] = TMath::Exp(params[param]+params[param+1]*x[var]);  \
continue;                                                         \
}
// case kexpo:
case kxexpo: R__EXPO(0);
case kyexpo: R__EXPO(1);
case kzexpo: R__EXPO(2);
case kxyexpo:{ pos++; int param = (oper & kTFOperMask);
tab[pos-1] = TMath::Exp(params[param]+params[param+1]*x[0]+params[param+2]*x[1]);
continue;  }

#define R__GAUS(var)                                                    \
{                                                                       \
pos++; int param = (oper & kTFOperMask);                             \
tab[pos-1] = params[param]*TMath::Gaus(x[var],params[param+1],params[param+2],IsNormalized()); \
continue;                                                            \
}

// case kgaus:
case kxgaus: R__GAUS(0);
case kygaus: R__GAUS(1);
case kzgaus: R__GAUS(2);
case kxygaus: {pos++; int param = (oper & kTFOperMask);
Double_t intermede1;
if (params[param+2] == 0) {
intermede1=1e10;
} else {
intermede1=Double_t((x[0]-params[param+1])/params[param+2]);
}
Double_t intermede2;
if (params[param+4] == 0) {
intermede2=1e10;
} else {
intermede2=Double_t((x[1]-params[param+3])/params[param+4]);
}
tab[pos-1] = params[param]*TMath::Exp(-0.5*(intermede1*intermede1+intermede2*intermede2));
continue; }

#define R__LANDAU(var)                                                                  \
{                                                                                       \
pos++; const int param = (oper & kTFOperMask);                                       \
tab[pos-1] = params[param]*TMath::Landau(x[var],params[param+1],params[param+2],IsNormalized()); \
continue;                                                                            \
}
// case klandau:
case kxlandau: R__LANDAU(0);
case kylandau: R__LANDAU(1);
case kzlandau: R__LANDAU(2);
case kxylandau: { pos++; int param = oper&0x7fffff /* ActionParams[i] */ ;
Double_t intermede1=TMath::Landau(x[0], params[param+1], params[param+2],IsNormalized());
Double_t intermede2=TMath::Landau(x[1], params[param+3], params[param+4],IsNormalized());
tab[pos-1] = params[param]*intermede1*intermede2;
continue;
}

#define R__POLY(var)                                                  \
{                                                                     \
pos++; int param = (oper & kTFOperMask);                           \
tab[pos-1] = 0; Double_t intermede = 1;                            \
Int_t inter = param/100; /* arrondit */                            \
Int_t int1= param-inter*100-1; /* aucune simplification ! (sic) */ \
for (j=0 ;j<inter+1;j++) {                                         \
tab[pos-1] += intermede*params[j+int1];                        \
intermede *= x[var];                                            \
}                                                                  \
continue;                                                          \
}
// case kpol:
case kxpol: R__POLY(0);
case kypol: R__POLY(1);
case kzpol: R__POLY(2);

case kDefinedVariable : {
if (!precalculated) {
precalculated = 1;
for(j=0;j<fNval;j++) param_calc[j]=DefinedValue(j);
}
pos++; tab[pos-1] = param_calc[(oper & kTFOperMask)];
continue;
}

case kDefinedString : {
int param = (oper & kTFOperMask);
if (!precalculated_str) {
precalculated_str=1;
for (j=0;j<fNstring;j++) string_calc[j]=DefinedString(j);
}
strpos++; stringStack[strpos-1] = string_calc[param];
pos++; tab[pos-1] = 0;
continue;
}

case kFunctionCall: {
// an external function call

int param = (oper & kTFOperMask);
int fno   = param / 1000;
int nargs = param % 1000;

// Retrieve the function
TMethodCall *method = (TMethodCall*)fFunctions.At(fno);

// Set the arguments
method->ResetParam();
if (nargs) {
UInt_t argloc = pos-nargs;
for(j=0;j<nargs;j++,argloc++,pos--) {
method->SetParam(tab[argloc]);
}
}
pos++;
Double_t ret;
method->Execute(ret);
tab[pos-1] = ret; // check for the correct conversion!

continue;
};
}
if (!TestBit(kOptimizationError)) {
SetBit(kOptimizationError);
Warning("EvalParOld","Found an unsupported opcode (%d)",oper >> kTFOperShift);
}
}
Double_t result0 = tab[0];
return result0;

}

//------------------------------------------------------------------------------
TString TFormula::GetExpFormula(Option_t *option) const
{
// Reconstruct the formula expression from the internal TFormula member variables
//
//   This function uses the internal member variables of TFormula to
//   construct the mathematical expression associated with the TFormula
//   instance. This function can be used to get an expanded version of the
//   expression originally assigned to the TFormula instance, i.e. that
//   the string returned by GetExpFormula() doesn't depend on other
//   TFormula object names.
//
//  if option contains "p" the returned string will contain the formula
//  expression with symbolic parameters, eg [0] replaced by the actual value
//  of the parameter. Example:
//  if expression in formula is: "[0]*(x>-[1])+[2]*exp(-[3]*x)"
//  and parameters are 3.25,-4.01,4.44,-0.04, GetExpFormula("p") will return:
//   "(3.25*(x>+4.01))+(4.44*exp(+0.04*x))"

if (fNoper>0) {
TString* tab=new TString[fNoper];
Bool_t* ismulti=new Bool_t[fNoper];
Int_t spos=0;

ismulti[0]=kFALSE;
Int_t optype;
Int_t j;
Int_t ternaryend = -1;
for(Int_t i=0;i<fNoper;i++){
optype = GetAction(i);

if (ternaryend==i) {
// The ? and : have been added to tab[spos-2]
if(ismulti[spos-1]){
tab[spos-2]=tab[spos-2]+"("+tab[spos-1]+")";
} else {
tab[spos-2]=tab[spos-2]+tab[spos-1];
}
spos--;
// Do not call continue since we need to
// do the rest of the loop.
}

// Boolean optimization breakpoint
if (optype==kBoolOptimize) { // -3) {
continue;
}

if (optype==kSignInv) { // -1) {
tab[spos-1]="-("+tab[spos-1]+")";
// i++;
continue;
}

//Simple name (parameter,pol0,landau, etc)
if (kexpo<=optype && optype<=kzpol) { // >=0) {
tab[spos]=fExpr[i];
ismulti[spos]=kFALSE;
spos++;
continue;
}

//constants, variables x,y,z,t, pi
if ((optype<=151 && optype>=140 && optype!=145) || (optype == 40)) {
tab[spos]=fExpr[i];
ismulti[spos]=kFALSE;
spos++;
continue;
}

//Basic operators (+,-,*,/,==,^,etc)
if(((optype>0 && optype<6) || optype==20 ||
(((optype>59 && optype<69) || (optype >75 && optype<82)) && spos>=2))) {
// if(optype==-20 && spos>=2){
if(ismulti[spos-2]){
tab[spos-2]="("+tab[spos-2]+")";
}
if(ismulti[spos-1]){
tab[spos-2]+=fExpr[i]+("("+tab[spos-1]+")");
}else{
tab[spos-2]+=fExpr[i]+tab[spos-1];
}
ismulti[spos-2]=kTRUE;
spos--;
continue;
}
//Ternary condition
if (optype==kJumpIf) {
if(ismulti[spos-1]){
tab[spos-1]="("+tab[spos-1]+")?";
} else {
tab[spos-1]=tab[spos-1]+"?";
}
continue;
}
if (optype==kJump) {
if(ismulti[spos-1]){
tab[spos-2]=tab[spos-2]+"("+tab[spos-1]+"):";
} else {
tab[spos-2]=tab[spos-2]+tab[spos-1]+":";
}
ternaryend = GetActionParam(i) + 1;
spos--;
continue;
}

//Functions
int offset = 0;
TString funcname = fExpr[i];
if((optype>9  && optype<16) ||
(optype>20 && optype<23) ||
(optype>29 && optype<34) ||
(optype>40 && optype<44) ||
(optype>69 && optype<76) ||
(optype==145)) {
//Functions with the format func(x)
offset = -1;
}

if((optype>15 && optype<20) ||
(optype>22 && optype<26)) {
//Functions with the format func(x,y)
offset = -2;
}
if(optype==145) {
int param = (fOper[i] & kTFOperMask);
//int fno   = param / 1000;
int nargs = param % 1000;
offset = -nargs;
// The function name contains return type and parameters types we need
// to trim them.
int depth;
for(j=0, depth=0;j<funcname.Length();++j) {
switch (funcname[j]) {
case '<':
++depth; break;
case '>':
--depth; break;
case ' ':
if (depth==0) {
funcname.Remove(0,j+1);
j = funcname.Length();
break;
}
}
}
Ssiz_t ind = funcname.First('(');
funcname.Remove(ind);
}
if (offset > 0) {
Error("GetExpFormula","Internal error, number of argument found is %d",-offset);
} else if (offset == 0) {
tab[spos]=funcname+"()";
ismulti[spos]=kFALSE;
spos += 1;
continue;
} else if (offset<=0 && (spos+offset>=0)) {
tab[spos+offset]=funcname+("("+tab[spos+offset]);
for (j=offset+1; j<0; j++){
tab[spos+offset]+=","+tab[spos+j];
}
tab[spos+offset]+=")";
ismulti[spos+offset]=kFALSE;
spos += offset+1;
continue;
}
}
if (ternaryend==fNoper) {
// The ? and : have been added to tab[spos-2]
if(ismulti[spos-1]){
tab[spos-2]=tab[spos-2]+"("+tab[spos-1]+")";
} else {
tab[spos-2]=tab[spos-2]+tab[spos-1];
}
spos--;
}

TString ret = "";
if (spos > 0) ret = tab[spos-1];
delete[] tab;
delete[] ismulti;

//if option "p" is specified, return the real values of parameters instead of [0]
TString opt = option;
opt.ToLower();
if (opt.Contains("p")) {
char pb[10];
char pbv[100];
for (j=0;j<fNpar;j++) {
snprintf(pb,10,"[%d]",j);
snprintf(pbv,100,"%g",fParams[j]);
ret.ReplaceAll(pb,pbv);
}
ret.ReplaceAll("--","+");
ret.ReplaceAll("+-","-");
}
return ret;
} else{
TString ret="";
return ret;
}
}

//______________________________________________________________________________
const TObject* TFormula::GetLinearPart(Int_t i)
{
// Return linear part.

if (!fLinearParts.IsEmpty())
return fLinearParts.UncheckedAt(i);
return 0;
}

//______________________________________________________________________________
Double_t TFormula::GetParameter(Int_t ipar) const
{
// Return value of parameter number ipar.

if (ipar <0 || ipar >= fNpar) return 0;
return fParams[ipar];
}

//______________________________________________________________________________
Double_t TFormula::GetParameter(const char *parName) const
{
// Return value of parameter named parName.

const Double_t kNaN = 1e-300;
Int_t index = GetParNumber(parName);
if (index==-1) {
return kNaN;
}
return GetParameter(index);
}

//______________________________________________________________________________
const char *TFormula::GetParName(Int_t ipar) const
{
// Return name of one parameter.

if (ipar <0 || ipar >= fNpar) return "";
if (fNames[ipar].Length() > 0) return (const char*)fNames[ipar];
return Form("p%d",ipar);
}

//______________________________________________________________________________
Int_t TFormula::GetParNumber(const char *parName) const
{
// Return parameter number by name.

if (!parName)
return -1;

for (Int_t i=0; i<fNpar; i++) {
if (!strcmp(GetParName(i),parName)) return i;
}
return -1;
}

//______________________________________________________________________________
Bool_t TFormula::IsString(Int_t oper) const
{
// Return true if the expression at the index 'oper' has to be treated as a string

return GetAction(oper) == kStringConst;
}

//______________________________________________________________________________
void TFormula::Print(Option_t *) const
{
// Dump this formula with its attributes.

Int_t i;
Printf(" %20s : %s Ndim= %d, Npar= %d, Noper= %d",GetName(),GetTitle(), fNdim,fNpar,fNoper);
for (i=0;i<fNoper;i++) {
Printf(" fExpr[%d] = %s  action = %d action param = %d ",
i,(const char*)fExpr[i],GetAction(i),GetActionParam(i));
}
//MI change
//
if (fNOperOptimized>0){
Printf("Optimized expression");
for (i=0;i<fNOperOptimized;i++) {
Printf(" fExpr[%d] = %s\t\t  action = %d action param = %d ",
i,(const char*)fExprOptimized[i],GetActionOptimized(i),GetActionParamOptimized(i));
}
}

if (!fNames) return;
if (!fParams) return;
for (i=0;i<fNpar;i++) {
Printf(" Par%3d  %20s = %g",i,GetParName(i),fParams[i]);
}
}

//______________________________________________________________________________
void TFormula::ProcessLinear(TString &formula)
{
// If the formula is for linear fitting, change the title to
// normal and fill the LinearParts array

TString formula2(formula);
char repl[20];
char *pch;
Int_t nf, offset, replsize;
//replace "++" with "+[i]*"
pch= (char*)strstr(formula.Data(), "++");
if (pch)
formula.Insert(0, "[0]*(");
pch= (char*)strstr(formula.Data(), "++");
if (pch){
//if there are "++", replaces them with +[i]*
nf = 1;
while (pch){
snprintf(repl,20, ")+[%d]*(", nf);
offset = pch-formula.Data();
if (nf<10) replsize = 7;
else if (nf<100) replsize = 8;
else replsize = 9;
formula.Replace(pch-formula.Data(), 2, repl, replsize);
pch = (char*)strstr(formula.Data()+offset, "++");
nf++;
}
formula.Append(')', 1);
} else {
//if there are no ++, create a new string with ++ instead of +[i]*
formula2=formula2(4, formula2.Length()-4);
pch= (char*)strchr(formula2.Data(), '[');
snprintf(repl,20, "++");
nf = 1;
while (pch){
offset = pch-formula2.Data()-1;
if (nf<10) replsize = 5;
else replsize = 6;
formula2.Replace(pch-formula2.Data()-1, replsize, repl, 2);
pch = (char*)strchr(formula2.Data()+offset, '[');
nf++;
}
}

fLinearParts.Expand(nf);
//break up the formula and fill the array of linear parts
TString replaceformula;
formula2 = formula2.ReplaceAll("++", 2, "|", 1);
TObjArray *oa = formula2.Tokenize("|");
TString replaceformula_name;
for (Int_t i=0; i<nf; i++) {
replaceformula = ((TObjString *)oa->UncheckedAt(i))->GetString();
replaceformula_name = "f_linear_";
replaceformula_name.Append(replaceformula);
TFormula *f = new TFormula(replaceformula_name.Data(), replaceformula.Data());
if (!f) {
Error("TFormula", "f_linear not allocated");
return;
}
{
R__LOCKGUARD2(gROOTMutex);
gROOT->GetListOfFunctions()->Remove(f);
}
f->SetBit(kNotGlobal, 1);
}
oa->Delete();
}

//______________________________________________________________________________
void TFormula::SetParameter(const char *name, Double_t value)
{
// Initialize parameter number ipar.

Int_t ipar = GetParNumber(name);
if (ipar <0 || ipar >= fNpar) return;
fParams[ipar] = value;
Update();
}

//______________________________________________________________________________
void TFormula::SetParameter(Int_t ipar, Double_t value)
{
// Initialize parameter number ipar.

if (ipar <0 || ipar >= fNpar) return;
fParams[ipar] = value;
Update();
}

//______________________________________________________________________________
void TFormula::SetParameters(const Double_t *params)
{
// Initialize array of all parameters.

for (Int_t i=0; i<fNpar;i++) {
fParams[i] = params[i];
}
Update();
}

//______________________________________________________________________________
void TFormula::SetParameters(Double_t p0,Double_t p1,Double_t p2,Double_t p3,Double_t p4
,Double_t p5,Double_t p6,Double_t p7,Double_t p8,Double_t p9,Double_t p10)
{
// Initialize up to 11 parameters
// All arguments except THE FIRST TWO are optional
// In case of a function with only one parameter, call this function with p1=0.
// Minimum two arguments are required to differentiate this function
// from the SetParameters(cont Double_t *params)

if (fNpar > 0) fParams[0] = p0;
if (fNpar > 1) fParams[1] = p1;
if (fNpar > 2) fParams[2] = p2;
if (fNpar > 3) fParams[3] = p3;
if (fNpar > 4) fParams[4] = p4;
if (fNpar > 5) fParams[5] = p5;
if (fNpar > 6) fParams[6] = p6;
if (fNpar > 7) fParams[7] = p7;
if (fNpar > 8) fParams[8] = p8;
if (fNpar > 9) fParams[9] = p9;
if (fNpar >10) fParams[10]= p10;
Update();
}

//______________________________________________________________________________
void TFormula::SetParName(Int_t ipar, const char *name)
{
// Set name of parameter number ipar

if (ipar <0 || ipar >= fNpar) return;
fNames[ipar] = name;
}

//______________________________________________________________________________
void TFormula::SetParNames(const char*name0,const char*name1,const char*name2,const char*name3,const char*name4,
const char*name5,const char*name6,const char*name7,const char*name8,const char*name9,const char*name10)
{
// Set up to 11 parameter names.

if (fNpar > 0) fNames[0] = name0;
if (fNpar > 1) fNames[1] = name1;
if (fNpar > 2) fNames[2] = name2;
if (fNpar > 3) fNames[3] = name3;
if (fNpar > 4) fNames[4] = name4;
if (fNpar > 5) fNames[5] = name5;
if (fNpar > 6) fNames[6] = name6;
if (fNpar > 7) fNames[7] = name7;
if (fNpar > 8) fNames[8] = name8;
if (fNpar > 9) fNames[9] = name9;
if (fNpar >10) fNames[10]= name10;
}

//______________________________________________________________________________
void TFormula::Streamer(TBuffer &b, const TClass *onfile_class)
{
// Stream a class object.

UInt_t R__s, R__c;
if (v==6) {
Error("Streamer","version 6 is not supported");
return;
}
Streamer(b, v, R__s, R__c, onfile_class);

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

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

UInt_t R__s, R__c;
if (v==6) {
Error("Streamer","version 6 is not supported");
return;
}
Streamer(b, v, R__s, R__c, nullptr);

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

//______________________________________________________________________________
void TFormula::Streamer(TBuffer &b, Int_t v, UInt_t R__s, UInt_t R__c, const TClass *onfile_class)
{
// specialized streamer function being able to read old TF1 versions as TF1Old in memory

//printf("Reading TFormula - version %d \n",v);
if (v > 3 ) {
b.ReadClassBuffer(TFormula::Class(), this, v, R__s, R__c, onfile_class);
if (!TestBit(kNotGlobal)) {
R__LOCKGUARD2(gROOTMutex);
}

// We need to reinstate (if possible) the TMethodCall.
if (fFunctions.GetLast()>=0) {
// Compiles will reset the parameter values so we need
// to temporarily keep them
Double_t *param = fParams;
TString *names = fNames;
Int_t npar = fNpar;
fParams = 0;
fNames = 0;
if (Compile()) {
Error("Streamer","error compiling formula");
return;
}
for (Int_t i = 0; i<npar && i<fNpar; ++i) fParams[i] = param[i];
delete [] param;
delete [] fNames;
fNames = names;
} else if (v<6) {
Convert(v);
}
Optimize();
return;
}
// version smaller or equal to 3
// process old versions before automatic schema evolution
TNamed::Streamer(b);
b >> fNdim;
b >> fNumber;
if (v > 1) b >> fNval;
if (v > 2) b >> fNstring;
fOper = new Int_t[gMAXOP];
if (fNoper) {
fExpr   = new TString[fNoper];
}
if (fNpar) {
fNames  = new TString[fNpar];
}
Int_t i;
for (i=0;i<fNoper;i++)  fExpr[i].Streamer(b);
for (i=0;i<fNpar;i++)   fNames[i].Streamer(b);
{
R__LOCKGUARD2(gROOTMutex);
if (gROOT->GetListOfFunctions()->FindObject(GetName())) return;
}
b.CheckByteCount(R__s, R__c, TFormula::IsA());

Convert(v);
// end of old versions

}

void TFormula::Convert(UInt_t /* fromVersion */)
{
// Convert the fOper of a TFormula version fromVersion to the current in memory version

enum {
kOldexpo         =  1000,
kOldgaus         =  2000,
kOldlandau       =  4000,
kOldxylandau     =  4500,
kOldConstants    =  50000,
kOldStrings      =  80000,
kOldVariable     = 100000,
kOldTreeString   = 105000,
kOldFormulaVar   = 110000,
kOldBoolOptimize = 120000,
kOldFunctionCall = 200000
};
int i,j;

for (i=0,j=0; i<fNoper; ++i,++j) {
Int_t action = fOper[i];
Int_t newActionCode = 0;
Int_t newActionParam = 0;

if ( action == 0) {

newActionCode = kSignInv;

Float_t aresult = 99.99;
sscanf((const char*)fExpr[i],"%g",&aresult);
R__ASSERT((aresult+1)<0.001);

++i; // skip the implied multiplication.

// For consistency and for Optimize to work correctly
// we need to remove the "-1" string in fExpr
for (int z=i; z<fNoper; ++z) {
fExpr[z-1] = fExpr[z];
}

} else  if ( action < 100 ) {
// basic operators and mathematical library

newActionCode = action;

} else if (action >= kOldFunctionCall) {
// Function call

newActionCode = kFunctionCall;
newActionParam = action-kOldFunctionCall;

} else if (action >= kOldBoolOptimize) {
// boolean operation optimizer

newActionCode = kBoolOptimize;
newActionParam = action-kOldBoolOptimize;

} else if (action >= kOldFormulaVar) {
// a variable

newActionCode = kVariable;
newActionParam = action-kOldFormulaVar;

} else if (action >= kOldTreeString) {
// a tree string

newActionCode = kDefinedString;
newActionParam = action-kOldTreeString;

} else if (action >= kOldVariable) {
// a tree variable

newActionCode = kDefinedVariable;
newActionParam = action-kOldVariable;

} else if (action == kOldStrings) {
// String

newActionCode = kStringConst;

} else if (action >= kOldConstants) {
// numerical value

newActionCode = kConstant;
newActionParam = action-kOldConstants;

} else if (action > 10000 && action < kOldConstants) {
// Polynomial

int var = action/10000; //arrondit
newActionCode = kpol + (var-1);
newActionParam = action - var*10000;

} else if (action >= 4600) {

Error("Convert","Unsupported value %d",action);

} else if (action > kOldxylandau) {
// xylandau

newActionCode = kxylandau;
newActionParam = action - (kOldxylandau+1);

} else if (action > kOldlandau) {
// landau, xlandau, ylandau or zlandau

newActionCode = klandau;
int var = action/100-40;
if (var) newActionCode += var;
newActionParam = action - var*100 - (kOldlandau+1);

} else if (action > 2500 && action < 2600) {
// xygaus

newActionCode = kxygaus;
newActionParam = action-2501;

}  else if (action > 2000 && action < 2500) {
//  gaus, xgaus, ygaus or zgaus

newActionCode = kgaus;
int var = action/100-20;
if (var) newActionCode += var;
newActionParam = action - var*100 - (kOldgaus+1);

} else if (action > 1500 && action < 1600) {
// xyexpo

newActionCode = kxyexpo;
newActionParam = action-1501;

} else if (action > 1000 && action < 1500) {
// expo or xexpo or yexpo or zexpo

newActionCode = kexpo;
int var = action/100-10;
if (var) newActionCode += var;
newActionParam = action - var*100 - (kOldexpo+1);

} if (action > 100 && action < 200) {
// Parameter substitution

newActionCode = kParameter;
newActionParam = action - 101;
}

SetAction( j, newActionCode, newActionParam );

}
if (i!=j) {
fNoper -= (i-j);
}

}

/////////////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
TOperOffset::TOperOffset()
{
//  TOper offset  - helper class for TFormula*
//                     specify type of operand
//                     fTypeX   = kVariable
//                              = kParameter
//                              = kConstant
//                     fOffestX = offset in corresponding array

fType0=0;
fType1=0;
fType2=0;
fType3=0;
fOffset0=0;
fOffset1=0;
fOffset2=0;
fOffset3=0;
fOldAction=0;
fToJump=0;
}

//______________________________________________________________________________
void  TFormula::MakePrimitive(const char *expr, Int_t pos)
{
//  MakePrimitive
//  find TFormulaPrimitive replacement for some operands

TString cbase(expr);
cbase.ReplaceAll("Double_t ","");
int paran = cbase.First("(");
// int nargs = 0;
if (paran>0) {
//nargs = 1;
cbase[paran]=0;
}

if (cbase=="<") cbase="XlY";
if (cbase=="<=") cbase="XleY";
if (cbase==">") cbase="XgY";
if (cbase==">=") cbase="XgeY";
if (cbase=="==" && GetActionOptimized(pos)!=kStringEqual) cbase="XeY";
if (cbase=="!=" && GetActionOptimized(pos)!=kStringNotEqual) cbase="XneY";

ROOT::v5::TFormulaPrimitive *prim = ROOT::v5::TFormulaPrimitive::FindFormula(cbase ,paran>0 ? cbase.Data() + paran + 1 : (const char*)0);
if (prim) {
fPredefined[pos] = prim;
if (prim->fType==10) {
SetActionOptimized(pos, kFD1);
}
if (prim->fType==110) {
SetActionOptimized(pos, kFD2);
}
if (prim->fType==1110) {
SetActionOptimized(pos, kFD3);
}
if (prim->fType==-1) {
SetActionOptimized(pos, kFDM);
}
if (prim->fType==0){
SetActionOptimized(pos,kConstant,fNconst);
fConst[fNconst] = prim->Eval(0);
fNconst++;
}
return;
}
}

//______________________________________________________________________________
void TFormula::Optimize()
{
// MI include
//
// Optimize formula
// 1.) Minimize the number of operands
//     a.)  several operanands are glued togther
//     b.)  some primitive functions glued together - exemp. (x+y) => PlusXY(x,y)
//     c.)  maximize number of standard calls minimizing number of jumps in Eval cases
//     d.)  variables, parameters and constants are mapped - using fOperOfssets0
//          Eval procedure use direct acces to data (only one corresponding case statement in eval procedure)
//
//          pdata[operand={Var,Par,Const}][offset]
//          pdata[fOperOffsets0[i]][fOperOffset1[i+1]]
// 2.) The fastest evaluation function is chosen at the end
//     a.) fOptimal := pointer to the fastest function for given evaluation string
//             switch(GetActionOptimized(0)){
//               case kData : {fOptimal= (TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive0; break;}
//               case kUnary : {fOptimal= (TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive1; break;}
//               case kBinary : {fOptimal= (TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive2; break;}
//               case kThree : {fOptimal= (TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive3; break;}
//               case kFDM : {fOptimal= (TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive4; break;}
//             }
//     b.) ex. fOptimal = ::EvalPrimitive0 - if it return only variable, constant or parameter
//                      = ::EvalParameter1 - if only one unary operation
//                      = ::EvalPrimitive2 - if only one binary operation
//                        .......

//
// Initialize data members
//

Int_t i;

if (fPredefined)    { delete [] fPredefined;    fPredefined    = 0;}
if (fOperOffset)    { delete [] fOperOffset;    fOperOffset    = 0;}
if (fExprOptimized) { delete [] fExprOptimized; fExprOptimized = 0;}
if (fOperOptimized) { delete [] fOperOptimized; fOperOptimized = 0;}

fExprOptimized   = new TString[fNoper];
fOperOptimized   = new Int_t[fNoper];
fPredefined      = new ROOT::v5::TFormulaPrimitive*[fNoper];
fOperOffset      = new TOperOffset[fNoper];
for (i=0; i<fNoper; i++) {
fExprOptimized[i]   = fExpr[i] ;
fOperOptimized[i]   = fOper[i];
fPredefined[i]= 0;
}

//
//Make primitives
//
for (i=0;i<fNoper;i++){
if (fExprOptimized[i].Data()) {
MakePrimitive(fExprOptimized[i].Data(), i);
}
}
//
Int_t maxfound   = fNoper+1;
Int_t *offset    = new Int_t[maxfound*16];
Int_t *optimized = new Int_t[maxfound];
//
//
ROOT::v5::TFormulaPrimitive*  primitive[10];
primitive[0] =  ROOT::v5::TFormulaPrimitive::FindFormula("PlusXY");
primitive[1] =  ROOT::v5::TFormulaPrimitive::FindFormula("MinusXY");
primitive[2] =  ROOT::v5::TFormulaPrimitive::FindFormula("MultXY");
primitive[3] =  ROOT::v5::TFormulaPrimitive::FindFormula("DivXY");
primitive[4] =  ROOT::v5::TFormulaPrimitive::FindFormula("XpYpZ");
primitive[5] =  ROOT::v5::TFormulaPrimitive::FindFormula("XxYxZ");
primitive[6] =  ROOT::v5::TFormulaPrimitive::FindFormula("XxYpZ");
primitive[7] =  ROOT::v5::TFormulaPrimitive::FindFormula("XpYxZ");
primitive[8] =  ROOT::v5::TFormulaPrimitive::FindFormula("Pow2");
primitive[9] =  ROOT::v5::TFormulaPrimitive::FindFormula("Pow3");
//
// set data pointers
//
for (i=0;i<fNoper;i++) optimized[i]=0;
//
for (i=0;i<fNoper;i++){
Int_t actionparam = GetActionParamOptimized(i);
Int_t action = GetActionOptimized(i);

if (action==kBoolOptimize){
//
// optimize booleans
//
fOperOffset[i].fType1     = actionparam/10;           //  operands to skip
fOperOffset[i].fOffset0   = actionparam%10;           //  1 is && , 2 is ||   - operand
fOperOffset[i].fToJump    = i+fOperOffset[i].fType1;  //  where we should  jump
continue;
}
if (action==kJump || action==kJumpIf) {
// Ternary condtional operator
fOperOffset[i].fType1     = action;
fOperOffset[i].fToJump    = actionparam;
}
//
if (action==kConstant&&i<fNoper-2){
//
// get offsets for kFDM operands
//
if (GetActionOptimized(i+1)==kConstant && GetActionOptimized(i+2)==kFDM){
optimized[i]=1;
optimized[i+1]=1;
i+=2;
fOperOffset[i].fType0=actionparam;
fOperOffset[i].fOffset0=GetActionParamOptimized(i-1);
Int_t offset2 =  int(fConst[fOperOffset[i].fOffset0]+0.4);
fOperOffset[i].fOffset0=offset2;
Int_t nparmax = offset2+fPredefined[i]->fNParameters;
if (nparmax>fNpar){ // increase expected number of parameters
fNpar=nparmax;
}
continue;
}
}
switch(action){
case kVariable : {action=kData; fOperOffset[i].fType0=0; break;}
case kParameter: {action=kData; fOperOffset[i].fType0=1; break;}
case kConstant : {action=kData; fOperOffset[i].fType0=2; break;}
}
//
fOperOffset[i].fOffset0 = GetActionParamOptimized(i);
SetActionOptimized(i,action, actionparam);    //set common data option
}
//
//
fNOperOptimized = fNoper;
//
for (i=0; i<fNoper; ++i)
{
//
if (!(GetActionOptimized(i)== kData)) continue;
offset[0] = fOperOffset[i].fType0;       //
offset[1] = fOperOptimized[i] & kTFOperMask;   // offset

if ((i+1) >= fNoper) continue;

if (GetActionOptimized(i+1)==kFD1){
optimized[i] = 1; // to be optimized
i++;
fOperOffset[i].fType0   = offset[0];
fOperOffset[i].fOffset0 = offset[1];
SetActionOptimized(i  ,kUnary);
continue;
}
optimized[i] = 1; // to be optimized
i++;
fOperOffset[i].fType0   = offset[0];
fOperOffset[i].fOffset0 = offset[1];
SetActionOptimized(i  ,kPlusD);
continue;
}
if (GetActionOptimized(i+1)==kMultiply){
optimized[i] = 1; // to be optimized
i++;
fOperOffset[i].fType0   = offset[0];
fOperOffset[i].fOffset0 = offset[1];
SetActionOptimized(i,kMultD);
continue;
}

if ((i+2) >= fNoper) continue;

//
//Binary operators
if (!(GetActionOptimized(i+1)== kData))  continue;
offset[2] = fOperOffset[i+1].fType0;
offset[3] = fOperOptimized[i+1] & kTFOperMask;   // offset
//
GetActionOptimized(i+2)==kMultiply || GetActionOptimized(i+2)==kDivide){

optimized[i] = 1; // to be optimized
optimized[i+1] = 1; // to be optimized
i+=2;
//
fOperOffset[i].fType0   = offset[0];
fOperOffset[i].fOffset0 = offset[1];
fOperOffset[i].fType1   = offset[2];
fOperOffset[i].fOffset1 = offset[3];
fOperOffset[i].fType2   = GetActionOptimized(i);  //remember old action
if (GetActionOptimized(i)==kSubstract) {fPredefined[i] = primitive[1];}
if (GetActionOptimized(i)==kMultiply) {
fPredefined[i]=primitive[2];
if (offset[0]==offset[2]&&offset[1]==offset[3]) {
fPredefined[i] = primitive[8];
SetActionOptimized(i,kUnary);
continue;
}
}
if (GetActionOptimized(i)==kDivide) {
fPredefined[i] = primitive[3];
}
SetActionOptimized(i,kBinary);
continue;
}

if ((i+3) >= fNoper) continue;

//
//operator 3
//
if (!(GetActionOptimized(i+2)== kData))  continue;
offset[4] = fOperOffset[i+2].fType0;
offset[5] = fOperOptimized[i+2] & kTFOperMask;   // offset
//
optimized[i+0]   = 1; // to be optimized
optimized[i+1] = 1; // to be optimized
optimized[i+2] = 1; // to be optimized
i+=3;
//
fOperOffset[i].fType0   = offset[0];
fOperOffset[i].fOffset0 = offset[1];
fOperOffset[i].fType1   = offset[2];
fOperOffset[i].fOffset1 = offset[3];
fOperOffset[i].fType2   = offset[4];
fOperOffset[i].fOffset2 = offset[5];
//
fOperOffset[i].fOldAction = GetActionOptimized(i);  //remember old action
if (GetActionOptimized(i)==kFD3) {
SetActionOptimized(i,kThree);
continue;
}
Int_t action=0;
Int_t action2=kThree;
if (GetActionOptimized(i)==kMultiply&&GetActionOptimized(i+1)==kMultiply) {
action=5;
if (offset[0]==offset[2]&&offset[1]==offset[3]&&offset[0]==offset[4]&&offset[1]==offset[5]){
fPredefined[i]=primitive[9];
action2=kUnary;
action =9;
}
}
//
optimized[i]=1;
i++;
fOperOffset[i].fType0   = offset[0];
fOperOffset[i].fOffset0 = offset[1];
fOperOffset[i].fType1 = offset[2];
fOperOffset[i].fOffset1 = offset[3];
fOperOffset[i].fType2 = offset[4];
fOperOffset[i].fOffset2 = offset[5];
fPredefined[i]=primitive[action];
SetActionOptimized(i,action2);
continue;
}
}
//
//
Int_t operO=0;
TString expr="";
Int_t *map0 = new Int_t[maxfound];   //remapping of the operands
Int_t *map1 = new Int_t[maxfound];   //remapping of the operands
for (i=0;i<fNoper;i++){
map0[i]     =  operO;
map1[operO] =  i;
fOperOptimized[operO] = fOperOptimized[i];
fPredefined[operO]    = fPredefined[i];
fOperOffset[operO]    = fOperOffset[i];
expr += fExprOptimized[i];
if (optimized[i]==0){
fExprOptimized[operO] = expr;
expr = "";
operO++;
}else{
expr += ",";
}
}
//
// Recalculate long jump for  Boolen optimize
//
for (i=0; i<fNOperOptimized; i++){
Int_t optaction = GetActionOptimized(i);
if (optaction==kBoolOptimize){
Int_t oldpos = fOperOffset[i].fToJump;
Int_t newpos = oldpos==fNoper ? fNOperOptimized : map0[oldpos];
fOperOffset[i].fToJump = newpos;   // new position to jump
Int_t actionop = GetActionParamOptimized(i) % 10;
switch (actionop) {
case 1: SetActionOptimized(i,kBoolOptimizeAnd,newpos);  break;
case 2: SetActionOptimized(i,kBoolOptimizeOr,newpos); break;
}
} else if (optaction==kJump || optaction==kJumpIf) {
Int_t oldpos = fOperOffset[i].fToJump;
Int_t newpos = oldpos==fNoper ? fNOperOptimized : map0[oldpos];
fOperOffset[i].fToJump = newpos;   // new position to jump
SetActionOptimized(i,optaction,newpos);
}
}

fNOperOptimized = operO;
//
fOptimal= (ROOT::v5::TFormulaPrimitive::TFuncG)&TFormula::EvalParFast;
if (fNOperOptimized==1) {
switch(GetActionOptimized(0)){
case kData   : {fOptimal= (ROOT::v5::TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive0; break;}
case kUnary  : {fOptimal= (ROOT::v5::TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive1; break;}
case kBinary : {fOptimal= (ROOT::v5::TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive2; break;}
case kThree  : {fOptimal= (ROOT::v5::TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive3; break;}
case kFDM    : {fOptimal= (ROOT::v5::TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive4; break;}
}
}

delete [] map1;
delete [] map0;
delete [] offset;
delete [] optimized;
}

//______________________________________________________________________________
Double_t TFormula::EvalPrimitive(const Double_t *x, const Double_t *params)
{
// Evaluate primitive formula

const Double_t  *pdata[3] = {x,(params!=0)?params:fParams, fConst};
Double_t result = pdata[fOperOffset->fType0][fOperOffset->fOffset0];
switch((fOperOptimized[0] >> kTFOperShift)) {
case kData          : return result;
case kUnary         : return (fPredefined[0]->fFunc10)(pdata[fOperOffset->fType0][fOperOffset->fOffset0]);
case kBinary         :return (fPredefined[0]->fFunc110)(result,
pdata[fOperOffset->fType1][fOperOffset->fOffset1]);

case kThree         :return (fPredefined[0]->fFunc1110)(result, pdata[fOperOffset->fType1][fOperOffset->fOffset1],
pdata[fOperOffset->fType2][fOperOffset->fOffset2]);
case kFDM         : return (fPredefined[0]->fFuncG)((Double_t*)&x[fOperOffset->fType0],
(Double_t*)&params[fOperOffset->fOffset0]);
}
return 0;
}

//______________________________________________________________________________
Double_t TFormula::EvalPrimitive0(const Double_t *x, const Double_t *params)
{
// Evaluate primitive formula

const Double_t  *pdata[3] = {x,(params!=0)?params:fParams, fConst};
return  pdata[fOperOffset->fType0][fOperOffset->fOffset0];
}

//______________________________________________________________________________
Double_t TFormula::EvalPrimitive1(const Double_t *x, const Double_t *params)
{
// Evaluate primitive formula

const Double_t  *pdata[3] = {x,(params!=0)?params:fParams, fConst};
return (fPredefined[0]->fFunc10)(pdata[fOperOffset->fType0][fOperOffset->fOffset0]);
}

//______________________________________________________________________________
Double_t TFormula::EvalPrimitive2(const Double_t *x, const Double_t *params)
{
// Evaluate primitive formula

const Double_t  *pdata[3] = {x,(params!=0)?params:fParams, fConst};
return (fPredefined[0]->fFunc110)(pdata[fOperOffset->fType0][fOperOffset->fOffset0],
pdata[fOperOffset->fType1][fOperOffset->fOffset1]);
}

//______________________________________________________________________________
Double_t TFormula::EvalPrimitive3(const Double_t *x, const Double_t *params)
{
// Evaluate primitive formula

const Double_t  *pdata[3] = {x,(params!=0)?params:fParams, fConst};
return (fPredefined[0]->fFunc1110)(pdata[fOperOffset->fType0][fOperOffset->fOffset0], pdata[fOperOffset->fType1][fOperOffset->fOffset1],
pdata[fOperOffset->fType2][fOperOffset->fOffset2]);
}

//______________________________________________________________________________
Double_t TFormula::EvalPrimitive4(const Double_t *x, const Double_t *params)
{
// Evaluate primitive formula

const Double_t *par = (params!=0)?params:fParams;
return (fPredefined[0]->fFuncG)((Double_t*)&x[fOperOffset->fType0],
(Double_t*)&par[fOperOffset->fOffset0]);
}

//______________________________________________________________________________
Double_t TFormula::EvalParFast(const Double_t *x, const Double_t *uparams)
{
// Evaluate this formula.
//
//   The current value of variables x,y,z,t is passed through the pointer x.
//   The parameters used will be the ones in the array params if params is given
//    otherwise parameters will be taken from the stored data members fParams
//Begin_Html
/*
<img src="gif/eval.gif">
*/
//End_Html

const Double_t  *pdata[3] = {x,(uparams!=0)?uparams:fParams, fConst};
//
Int_t i,j;
Double_t tab[kMAXFOUND];
const char *stringStack[gMAXSTRINGFOUND];
Double_t param_calc[kMAXFOUND];
char *string_calc[gMAXSTRINGFOUND];
Int_t precalculated = 0;
Int_t precalculated_str = 0;

Double_t *params;

if (uparams) {
//for (j=0;j<fNpar;j++) fParams[j] = params[j];
params = const_cast<Double_t*>(uparams);
} else {
params = fParams;
}

//if (params) {
// for (j=0;j<fNpar;j++) fParams[j] = params[j];
//}
UInt_t pos    = 0;
UInt_t strpos = 0;
//   for (i=0; i<fNoper; ++i) {
for (i=0; i<fNOperOptimized; ++i) {
//
const int oper = fOperOptimized[i];
const int opcode = oper >> kTFOperShift;

switch(opcode) {  // FREQUENTLY USED OPERATION
case kData      : tab[pos] = pdata[fOperOffset[i].fType0][fOperOffset[i].fOffset0]; pos++;continue;
case kPlusD     : tab[pos-1]+= pdata[fOperOffset[i].fType0][fOperOffset[i].fOffset0]; continue;
case kMultD     : tab[pos-1]*= pdata[fOperOffset[i].fType0][fOperOffset[i].fOffset0]; continue;
case kAdd       : pos--; tab[pos-1] += tab[pos]; continue;
case kSubstract : pos--; tab[pos-1] -= tab[pos]; continue;
case kMultiply  : pos--; tab[pos-1] *= tab[pos]; continue;
case kDivide    : pos--; if (tab[pos] == 0) tab[pos-1] = 0; //  division by 0
else     tab[pos-1] /= tab[pos];
continue;
case kUnary     : tab[pos] = (fPredefined[i]->fFunc10)(pdata[fOperOffset[i].fType0][fOperOffset[i].fOffset0]); pos++;continue;
case kBinary    : tab[pos] = (fPredefined[i]->fFunc110)(pdata[fOperOffset[i].fType0][fOperOffset[i].fOffset0],
pdata[fOperOffset[i].fType1][fOperOffset[i].fOffset1]);pos++;continue;

case kThree     : tab[pos]   = (fPredefined[i]->fFunc1110)(pdata[fOperOffset[i].fType0][fOperOffset[i].fOffset0],
pdata[fOperOffset[i].fType1][fOperOffset[i].fOffset1],
pdata[fOperOffset[i].fType2][fOperOffset[i].fOffset2]); pos++; continue;

case kFDM       : tab[pos] = (fPredefined[i]->fFuncG)(&x[fOperOffset[i].fType0],&params[fOperOffset[i].fOffset0]); pos++;continue;
case kFD1       : tab[pos-1]   =(fPredefined[i]->fFunc10)(tab[pos-1]); continue;
case kFD2       :    pos--; tab[pos-1]   = (fPredefined[i]->fFunc110)(tab[pos-1],tab[pos]); continue;
case kFD3       :    pos-=2; tab[pos-1]   = (fPredefined[i]->fFunc1110)(tab[pos-1],tab[pos],tab[pos+1]); continue;
}
//
switch(opcode) {
case kBoolOptimizeAnd: {
if (!tab[pos-1]) i=fOperOffset[i].fToJump; continue;
}
case kBoolOptimizeOr: {
if (tab[pos-1])  i=fOperOffset[i].fToJump; continue;
}
case kAnd  : pos--; tab[pos-1] = (bool)tab[pos];  continue;  // use the fact that other were check before - see bool optimize
case kOr   : pos--; tab[pos-1] = (bool)tab[pos];  continue;
}
switch(opcode) {
//    case kabs  : tab[pos-1] = TMath::Abs(tab[pos-1]); continue;
case kabs  : if (tab[pos-1]<0) tab[pos-1]=-tab[pos-1]; continue;
case ksign : if (tab[pos-1] < 0) tab[pos-1] = -1; else tab[pos-1] = 1; continue;
case kint  : tab[pos-1] = Double_t(Int_t(tab[pos-1])); continue;
case kpow  : pos--; tab[pos-1] = TMath::Power(tab[pos-1],tab[pos]); continue;

case kModulo     : {pos--;
Long64_t int1((Long64_t)tab[pos-1]);
Long64_t int2((Long64_t)tab[pos]);
tab[pos-1] = Double_t(int1%int2);
continue;}

case kStringConst: { strpos++; stringStack[strpos-1] = (char*)fExprOptimized[i].Data(); pos++; tab[pos-1] = 0; continue; }
case kfmod : pos--; tab[pos-1] = fmod(tab[pos-1],tab[pos]); continue;

case kstrstr : strpos -= 2; pos-=2; pos++;
if (strstr(stringStack[strpos],stringStack[strpos+1])) tab[pos-1]=1;
else tab[pos-1]=0; continue;
case kpi   : pos++; tab[pos-1] = TMath::ACos(-1); continue;

case kSignInv: tab[pos-1] = -1 * tab[pos-1]; continue;

case krndm : pos++; tab[pos-1] = gRandom->Rndm(1); continue;

case kEqual: pos--; if (tab[pos-1] == tab[pos]) tab[pos-1]=1;
else tab[pos-1]=0; continue;
case kNotEqual : pos--; if (tab[pos-1] != tab[pos]) tab[pos-1]=1;
else tab[pos-1]=0; continue;
case kNot : if (tab[pos-1]!=0) tab[pos-1] = 0; else tab[pos-1] = 1; continue;

case kStringEqual : strpos -= 2; pos -=2 ; pos++;
if (!strcmp(stringStack[strpos+1],stringStack[strpos])) tab[pos-1]=1;
else tab[pos-1]=0; continue;
case kStringNotEqual: strpos -= 2; pos -= 2; pos++;
if (strcmp(stringStack[strpos+1],stringStack[strpos])) tab[pos-1]=1;
else tab[pos-1]=0; continue;

case kBitAnd : pos--; tab[pos-1]= ((Int_t) tab[pos-1]) & ((Int_t) tab[pos]); continue;
case kBitOr  : pos--; tab[pos-1]= ((Int_t) tab[pos-1]) | ((Int_t) tab[pos]); continue;
case kLeftShift : pos--; tab[pos-1]= ((Int_t) tab[pos-1]) <<((Int_t) tab[pos]); continue;
case kRightShift: pos--; tab[pos-1]= ((Int_t) tab[pos-1]) >>((Int_t) tab[pos]); continue;

case kJump   : i = (oper & kTFOperMask); continue;
case kJumpIf : pos--; if (!tab[pos]) i = (oper & kTFOperMask); continue;

case kBoolOptimize: {
// boolean operation optimizer

int param = (oper & kTFOperMask);
int op = param % 10; // 1 is && , 2 is ||

if (op == 1 && (!tab[pos-1]) ) {
// &&: skip the right part if the left part is already false

i +=  param / 10;

// Preserve the existing behavior (i.e. the result of a&&b is
// either 0 or 1)
tab[pos-1] = 0;

} else if (op == 2 && tab[pos-1] ) {
// ||: skip the right part if the left part is already true

i +=  param / 10;

// Preserve the existing behavior (i.e. the result of a||b is
// either 0 or 1)
tab[pos-1] = 1;

}

continue;
}

}
switch(opcode) {

#define R__EXPO(var)                                                         \
{                                                                   \
pos++; int param = (oper & kTFOperMask);                          \
tab[pos-1] = TMath::Exp(params[param]+params[param+1]*x[var]);    \
continue;                                                         \
}
// case kexpo:
case kxexpo: R__EXPO(0);
case kyexpo: R__EXPO(1);
case kzexpo: R__EXPO(2);
case kxyexpo:{  pos++; int param = (oper & kTFOperMask);
tab[pos-1] = TMath::Exp(params[param]+params[param+1]*x[0]+params[param+2]*x[1]);
continue;  }
#ifdef R__GAUS
#undef R__GAUS
#endif
#define R__GAUS(var)                                                                           \
{                                                                         \
pos++; int param = (oper & kTFOperMask);                                  \
tab[pos-1] = params[param]*TMath::Gaus(x[var],params[param+1],          \
params[param+2],IsNormalized()); \
continue;                                                                 \
}

// case kgaus:
case kxgaus: R__GAUS(0);
case kygaus: R__GAUS(1);
case kzgaus: R__GAUS(2);
case kxygaus: { pos++; int param = (oper & kTFOperMask);
Double_t intermede1;
if (params[param+2] == 0) {
intermede1=1e10;
} else {
intermede1=Double_t((x[0]-params[param+1])/params[param+2]);
}
Double_t intermede2;
if (params[param+4] == 0) {
intermede2=1e10;
} else {
intermede2=Double_t((x[1]-params[param+3])/params[param+4]);
}
tab[pos-1] = params[param]*TMath::Exp(-0.5*(intermede1*intermede1+intermede2*intermede2));
continue; }

#define R__LANDAU(var)                                                                  \
{                                                                                       \
pos++; const int param = (oper & kTFOperMask);                                       \
tab[pos-1] = params[param]*TMath::Landau(x[var],params[param+1],params[param+2],IsNormalized()); \
continue;                                                                            \
}
// case klandau:
case kxlandau: R__LANDAU(0);
case kylandau: R__LANDAU(1);
case kzlandau: R__LANDAU(2);
case kxylandau: { pos++; int param = oper&0x7fffff /* ActionParams[i] */ ;
Double_t intermede1=TMath::Landau(x[0], params[param+1], params[param+2],IsNormalized());
Double_t intermede2=TMath::Landau(x[1], params[param+3], params[param+4],IsNormalized());
tab[pos-1] = params[param]*intermede1*intermede2;
continue;
}

#define R__POLY(var)                                                                       \
{                                                                  \
pos++; int param = (oper & kTFOperMask);                           \
tab[pos-1] = 0; Double_t intermede = 1;                            \
Int_t inter = param/100; /* arrondit */                            \
Int_t int1= param-inter*100-1; /* aucune simplification ! (sic) */ \
for (j=0 ;j<inter+1;j++) {                                         \
tab[pos-1] += intermede*params[j+int1];                           \
intermede *= x[var];                                               \
}                                                                  \
continue;                                                          \
}
// case kpol:
case kxpol: R__POLY(0);
case kypol: R__POLY(1);
case kzpol: R__POLY(2);

case kDefinedVariable : {
if (!precalculated) {
precalculated = 1;
for(j=0;j<fNval;j++) param_calc[j]=DefinedValue(j);
}
pos++; tab[pos-1] = param_calc[(oper & kTFOperMask)];
continue;
}

case kDefinedString : {
int param = (oper & kTFOperMask);
if (!precalculated_str) {
precalculated_str=1;
for (j=0;j<fNstring;j++) string_calc[j]=DefinedString(j);
}
strpos++; stringStack[strpos-1] = string_calc[param];
pos++; tab[pos-1] = 0;
continue;
}

case kFunctionCall: {
// an external function call

int param = (oper & kTFOperMask);
int fno   = param / 1000;
int nargs = param % 1000;

// Retrieve the function
TMethodCall *method = (TMethodCall*)fFunctions.At(fno);

// Set the arguments
method->ResetParam();
if (nargs) {
UInt_t argloc = pos-nargs;
for(j=0;j<nargs;j++,argloc++,pos--) {
method->SetParam(tab[argloc]);
}
}
pos++;
Double_t ret;
method->Execute(ret);
tab[pos-1] = ret; // check for the correct conversion!

continue;
};
}
if (!TestBit(kOptimizationError)) {
SetBit(kOptimizationError);
Warning("EvalParFast","Found an unsupported optmized opcode (%d)",oper >> kTFOperShift);
}
}
Double_t result0 = tab[0];
return result0;

}

//______________________________________________________________________________
Int_t TFormula::PreCompile()
{
// Pre compile function

TString str = fTitle;
if (str.Length()<3) return 1;
if (str[str.Length()-1]!='+'&&str[str.Length()-2]!='+') return 1;
str[str.Length()-2]=0;
TString funName("preformula_");
funName += fName;
if (ROOT::v5::TFormulaPrimitive::FindFormula(funName)) return 0;
TString fileName;
fileName.Form("/tmp/%s.C",funName.Data());

FILE *hf;
hf = fopen(fileName.Data(),"w");
if (hf == 0) {
Error("PreCompile","Unable to open the file %s for writing.",fileName.Data());
return 1;
}
fprintf(hf,   "/////////////////////////////////////////////////////////////////////////\n");
fprintf(hf,   "//   This code has been automatically generated \n");
//
fprintf(hf,   "Double_t %s(Double_t *x, Double_t *p){",funName.Data());
fprintf(hf,   "return (%s);\n}",str.Data());

//             clname,method->GetName(),clname,method->GetName(),clname,method->GetName());
fclose(hf);

return 0;

}

//______________________________________________________________________________
void TFormula::SetMaxima(Int_t maxop, Int_t maxpar, Int_t maxconst)
{
// static function to set the maximum value of 3 parameters
//  -maxop    : maximum number of operations
//  -maxpar   : maximum number of parameters
//  -maxconst : maximum number of constants
// None of these parameters cannot be less than 10 (default is 1000)
// call this function to increase one or all maxima when processing
// very complex formula, eg TFormula::SetMaxima(100000,1000,1000000);
// If you process many functions with a small number of operations/parameters
// you may gain some memory and performance by decreasing these values.

gMAXOP    = TMath::Max(10,maxop);
gMAXPAR   = TMath::Max(10,maxpar);
gMAXCONST = TMath::Max(10,maxconst);
}

//______________________________________________________________________________
void TFormula::GetMaxima(Int_t& maxop, Int_t& maxpar, Int_t& maxconst)
{
// static function to get the maximum value of 3 parameters
//  -maxop    : maximum number of operations
//  -maxpar   : maximum number of parameters
//  -maxconst : maximum number of constants

maxop = gMAXOP;
maxpar = gMAXPAR;
maxconst = gMAXCONST;
}

} // end namespace v5

} // end namespace ROOT
```
TFormula_v5.cxx:1
TFormula_v5.cxx:2
TFormula_v5.cxx:3
TFormula_v5.cxx:4
TFormula_v5.cxx:5
TFormula_v5.cxx:6
TFormula_v5.cxx:7
TFormula_v5.cxx:8
TFormula_v5.cxx:9
TFormula_v5.cxx:10
TFormula_v5.cxx:11
TFormula_v5.cxx:12
TFormula_v5.cxx:13
TFormula_v5.cxx:14
TFormula_v5.cxx:15
TFormula_v5.cxx:16
TFormula_v5.cxx:17
TFormula_v5.cxx:18
TFormula_v5.cxx:19
TFormula_v5.cxx:20
TFormula_v5.cxx:21
TFormula_v5.cxx:22
TFormula_v5.cxx:23
TFormula_v5.cxx:24
TFormula_v5.cxx:25
TFormula_v5.cxx:26
TFormula_v5.cxx:27
TFormula_v5.cxx:28
TFormula_v5.cxx:29
TFormula_v5.cxx:30
TFormula_v5.cxx:31
TFormula_v5.cxx:32
TFormula_v5.cxx:33
TFormula_v5.cxx:34
TFormula_v5.cxx:35
TFormula_v5.cxx:36
TFormula_v5.cxx:37
TFormula_v5.cxx:38
TFormula_v5.cxx:39
TFormula_v5.cxx:40
TFormula_v5.cxx:41
TFormula_v5.cxx:42
TFormula_v5.cxx:43
TFormula_v5.cxx:44
TFormula_v5.cxx:45
TFormula_v5.cxx:46
TFormula_v5.cxx:47
TFormula_v5.cxx:48
TFormula_v5.cxx:49
TFormula_v5.cxx:50
TFormula_v5.cxx:51
TFormula_v5.cxx:52
TFormula_v5.cxx:53
TFormula_v5.cxx:54
TFormula_v5.cxx:55
TFormula_v5.cxx:56
TFormula_v5.cxx:57
TFormula_v5.cxx:58
TFormula_v5.cxx:59
TFormula_v5.cxx:60
TFormula_v5.cxx:61
TFormula_v5.cxx:62
TFormula_v5.cxx:63
TFormula_v5.cxx:64
TFormula_v5.cxx:65
TFormula_v5.cxx:66
TFormula_v5.cxx:67
TFormula_v5.cxx:68
TFormula_v5.cxx:69
TFormula_v5.cxx:70
TFormula_v5.cxx:71
TFormula_v5.cxx:72
TFormula_v5.cxx:73
TFormula_v5.cxx:74
TFormula_v5.cxx:75
TFormula_v5.cxx:76
TFormula_v5.cxx:77
TFormula_v5.cxx:78
TFormula_v5.cxx:79
TFormula_v5.cxx:80
TFormula_v5.cxx:81
TFormula_v5.cxx:82
TFormula_v5.cxx:83
TFormula_v5.cxx:84
TFormula_v5.cxx:85
TFormula_v5.cxx:86
TFormula_v5.cxx:87
TFormula_v5.cxx:88
TFormula_v5.cxx:89
TFormula_v5.cxx:90
TFormula_v5.cxx:91
TFormula_v5.cxx:92
TFormula_v5.cxx:93
TFormula_v5.cxx:94
TFormula_v5.cxx:95
TFormula_v5.cxx:96
TFormula_v5.cxx:97
TFormula_v5.cxx:98
TFormula_v5.cxx:99
TFormula_v5.cxx:100
TFormula_v5.cxx:101
TFormula_v5.cxx:102
TFormula_v5.cxx:103
TFormula_v5.cxx:104
TFormula_v5.cxx:105
TFormula_v5.cxx:106
TFormula_v5.cxx:107
TFormula_v5.cxx:108
TFormula_v5.cxx:109
TFormula_v5.cxx:110
TFormula_v5.cxx:111
TFormula_v5.cxx:112
TFormula_v5.cxx:113
TFormula_v5.cxx:114
TFormula_v5.cxx:115
TFormula_v5.cxx:116
TFormula_v5.cxx:117
TFormula_v5.cxx:118
TFormula_v5.cxx:119
TFormula_v5.cxx:120
TFormula_v5.cxx:121
TFormula_v5.cxx:122
TFormula_v5.cxx:123
TFormula_v5.cxx:124
TFormula_v5.cxx:125
TFormula_v5.cxx:126
TFormula_v5.cxx:127
TFormula_v5.cxx:128
TFormula_v5.cxx:129
TFormula_v5.cxx:130
TFormula_v5.cxx:131
TFormula_v5.cxx:132
TFormula_v5.cxx:133
TFormula_v5.cxx:134
TFormula_v5.cxx:135
TFormula_v5.cxx:136
TFormula_v5.cxx:137
TFormula_v5.cxx:138
TFormula_v5.cxx:139
TFormula_v5.cxx:140
TFormula_v5.cxx:141
TFormula_v5.cxx:142
TFormula_v5.cxx:143
TFormula_v5.cxx:144
TFormula_v5.cxx:145
TFormula_v5.cxx:146
TFormula_v5.cxx:147
TFormula_v5.cxx:148
TFormula_v5.cxx:149
TFormula_v5.cxx:150
TFormula_v5.cxx:151
TFormula_v5.cxx:152
TFormula_v5.cxx:153
TFormula_v5.cxx:154
TFormula_v5.cxx:155
TFormula_v5.cxx:156
TFormula_v5.cxx:157
TFormula_v5.cxx:158
TFormula_v5.cxx:159
TFormula_v5.cxx:160
TFormula_v5.cxx:161
TFormula_v5.cxx:162
TFormula_v5.cxx:163
TFormula_v5.cxx:164
TFormula_v5.cxx:165
TFormula_v5.cxx:166
TFormula_v5.cxx:167
TFormula_v5.cxx:168
TFormula_v5.cxx:169
TFormula_v5.cxx:170
TFormula_v5.cxx:171
TFormula_v5.cxx:172
TFormula_v5.cxx:173
TFormula_v5.cxx:174
TFormula_v5.cxx:175
TFormula_v5.cxx:176
TFormula_v5.cxx:177
TFormula_v5.cxx:178
TFormula_v5.cxx:179
TFormula_v5.cxx:180
TFormula_v5.cxx:181
TFormula_v5.cxx:182
TFormula_v5.cxx:183
TFormula_v5.cxx:184
TFormula_v5.cxx:185
TFormula_v5.cxx:186
TFormula_v5.cxx:187
TFormula_v5.cxx:188
TFormula_v5.cxx:189
TFormula_v5.cxx:190
TFormula_v5.cxx:191
TFormula_v5.cxx:192
TFormula_v5.cxx:193
TFormula_v5.cxx:194
TFormula_v5.cxx:195
TFormula_v5.cxx:196
TFormula_v5.cxx:197
TFormula_v5.cxx:198
TFormula_v5.cxx:199
TFormula_v5.cxx:200
TFormula_v5.cxx:201
TFormula_v5.cxx:202
TFormula_v5.cxx:203
TFormula_v5.cxx:204
TFormula_v5.cxx:205
TFormula_v5.cxx:206
TFormula_v5.cxx:207
TFormula_v5.cxx:208
TFormula_v5.cxx:209
TFormula_v5.cxx:210
TFormula_v5.cxx:211
TFormula_v5.cxx:212
TFormula_v5.cxx:213
TFormula_v5.cxx:214
TFormula_v5.cxx:215
TFormula_v5.cxx:216
TFormula_v5.cxx:217
TFormula_v5.cxx:218
TFormula_v5.cxx:219
TFormula_v5.cxx:220
TFormula_v5.cxx:221
TFormula_v5.cxx:222
TFormula_v5.cxx:223
TFormula_v5.cxx:224
TFormula_v5.cxx:225
TFormula_v5.cxx:226
TFormula_v5.cxx:227
TFormula_v5.cxx:228
TFormula_v5.cxx:229
TFormula_v5.cxx:230
TFormula_v5.cxx:231
TFormula_v5.cxx:232
TFormula_v5.cxx:233
TFormula_v5.cxx:234
TFormula_v5.cxx:235
TFormula_v5.cxx:236
TFormula_v5.cxx:237
TFormula_v5.cxx:238
TFormula_v5.cxx:239
TFormula_v5.cxx:240
TFormula_v5.cxx:241
TFormula_v5.cxx:242
TFormula_v5.cxx:243
TFormula_v5.cxx:244
TFormula_v5.cxx:245
TFormula_v5.cxx:246
TFormula_v5.cxx:247
TFormula_v5.cxx:248
TFormula_v5.cxx:249
TFormula_v5.cxx:250
TFormula_v5.cxx:251
TFormula_v5.cxx:252
TFormula_v5.cxx:253
TFormula_v5.cxx:254
TFormula_v5.cxx:255
TFormula_v5.cxx:256
TFormula_v5.cxx:257
TFormula_v5.cxx:258
TFormula_v5.cxx:259
TFormula_v5.cxx:260
TFormula_v5.cxx:261
TFormula_v5.cxx:262
TFormula_v5.cxx:263
TFormula_v5.cxx:264
TFormula_v5.cxx:265
TFormula_v5.cxx:266
TFormula_v5.cxx:267
TFormula_v5.cxx:268
TFormula_v5.cxx:269
TFormula_v5.cxx:270
TFormula_v5.cxx:271
TFormula_v5.cxx:272
TFormula_v5.cxx:273
TFormula_v5.cxx:274
TFormula_v5.cxx:275
TFormula_v5.cxx:276
TFormula_v5.cxx:277
TFormula_v5.cxx:278
TFormula_v5.cxx:279
TFormula_v5.cxx:280
TFormula_v5.cxx:281
TFormula_v5.cxx:282
TFormula_v5.cxx:283
TFormula_v5.cxx:284
TFormula_v5.cxx:285
TFormula_v5.cxx:286
TFormula_v5.cxx:287
TFormula_v5.cxx:288
TFormula_v5.cxx:289
TFormula_v5.cxx:290
TFormula_v5.cxx:291
TFormula_v5.cxx:292
TFormula_v5.cxx:293
TFormula_v5.cxx:294
TFormula_v5.cxx:295
TFormula_v5.cxx:296
TFormula_v5.cxx:297
TFormula_v5.cxx:298
TFormula_v5.cxx:299
TFormula_v5.cxx:300
TFormula_v5.cxx:301
TFormula_v5.cxx:302
TFormula_v5.cxx:303
TFormula_v5.cxx:304
TFormula_v5.cxx:305
TFormula_v5.cxx:306
TFormula_v5.cxx:307
TFormula_v5.cxx:308
TFormula_v5.cxx:309
TFormula_v5.cxx:310
TFormula_v5.cxx:311
TFormula_v5.cxx:312
TFormula_v5.cxx:313
TFormula_v5.cxx:314
TFormula_v5.cxx:315
TFormula_v5.cxx:316
TFormula_v5.cxx:317
TFormula_v5.cxx:318
TFormula_v5.cxx:319
TFormula_v5.cxx:320
TFormula_v5.cxx:321
TFormula_v5.cxx:322
TFormula_v5.cxx:323
TFormula_v5.cxx:324
TFormula_v5.cxx:325
TFormula_v5.cxx:326
TFormula_v5.cxx:327
TFormula_v5.cxx:328
TFormula_v5.cxx:329
TFormula_v5.cxx:330
TFormula_v5.cxx:331
TFormula_v5.cxx:332
TFormula_v5.cxx:333
TFormula_v5.cxx:334
TFormula_v5.cxx:335
TFormula_v5.cxx:336
TFormula_v5.cxx:337
TFormula_v5.cxx:338
TFormula_v5.cxx:339
TFormula_v5.cxx:340
TFormula_v5.cxx:341
TFormula_v5.cxx:342
TFormula_v5.cxx:343
TFormula_v5.cxx:344
TFormula_v5.cxx:345
TFormula_v5.cxx:346
TFormula_v5.cxx:347
TFormula_v5.cxx:348
TFormula_v5.cxx:349
TFormula_v5.cxx:350
TFormula_v5.cxx:351
TFormula_v5.cxx:352
TFormula_v5.cxx:353
TFormula_v5.cxx:354
TFormula_v5.cxx:355
TFormula_v5.cxx:356
TFormula_v5.cxx:357
TFormula_v5.cxx:358
TFormula_v5.cxx:359
TFormula_v5.cxx:360
TFormula_v5.cxx:361
TFormula_v5.cxx:362
TFormula_v5.cxx:363
TFormula_v5.cxx:364
TFormula_v5.cxx:365
TFormula_v5.cxx:366
TFormula_v5.cxx:367
TFormula_v5.cxx:368
TFormula_v5.cxx:369
TFormula_v5.cxx:370
TFormula_v5.cxx:371
TFormula_v5.cxx:372
TFormula_v5.cxx:373
TFormula_v5.cxx:374
TFormula_v5.cxx:375
TFormula_v5.cxx:376
TFormula_v5.cxx:377
TFormula_v5.cxx:378
TFormula_v5.cxx:379
TFormula_v5.cxx:380
TFormula_v5.cxx:381
TFormula_v5.cxx:382
TFormula_v5.cxx:383
TFormula_v5.cxx:384
TFormula_v5.cxx:385
TFormula_v5.cxx:386
TFormula_v5.cxx:387
TFormula_v5.cxx:388
TFormula_v5.cxx:389
TFormula_v5.cxx:390
TFormula_v5.cxx:391
TFormula_v5.cxx:392
TFormula_v5.cxx:393
TFormula_v5.cxx:394
TFormula_v5.cxx:395
TFormula_v5.cxx:396
TFormula_v5.cxx:397
TFormula_v5.cxx:398
TFormula_v5.cxx:399
TFormula_v5.cxx:400
TFormula_v5.cxx:401
TFormula_v5.cxx:402
TFormula_v5.cxx:403
TFormula_v5.cxx:404
TFormula_v5.cxx:405
TFormula_v5.cxx:406
TFormula_v5.cxx:407
TFormula_v5.cxx:408
TFormula_v5.cxx:409
TFormula_v5.cxx:410
TFormula_v5.cxx:411
TFormula_v5.cxx:412
TFormula_v5.cxx:413
TFormula_v5.cxx:414
TFormula_v5.cxx:415
TFormula_v5.cxx:416
TFormula_v5.cxx:417
TFormula_v5.cxx:418
TFormula_v5.cxx:419
TFormula_v5.cxx:420
TFormula_v5.cxx:421
TFormula_v5.cxx:422
TFormula_v5.cxx:423
TFormula_v5.cxx:424
TFormula_v5.cxx:425
TFormula_v5.cxx:426
TFormula_v5.cxx:427
TFormula_v5.cxx:428
TFormula_v5.cxx:429
TFormula_v5.cxx:430
TFormula_v5.cxx:431
TFormula_v5.cxx:432
TFormula_v5.cxx:433
TFormula_v5.cxx:434
TFormula_v5.cxx:435
TFormula_v5.cxx:436
TFormula_v5.cxx:437
TFormula_v5.cxx:438
TFormula_v5.cxx:439
TFormula_v5.cxx:440
TFormula_v5.cxx:441
TFormula_v5.cxx:442
TFormula_v5.cxx:443
TFormula_v5.cxx:444
TFormula_v5.cxx:445
TFormula_v5.cxx:446
TFormula_v5.cxx:447
TFormula_v5.cxx:448
TFormula_v5.cxx:449
TFormula_v5.cxx:450
TFormula_v5.cxx:451
TFormula_v5.cxx:452
TFormula_v5.cxx:453
TFormula_v5.cxx:454
TFormula_v5.cxx:455
TFormula_v5.cxx:456
TFormula_v5.cxx:457
TFormula_v5.cxx:458
TFormula_v5.cxx:459
TFormula_v5.cxx:460
TFormula_v5.cxx:461
TFormula_v5.cxx:462
TFormula_v5.cxx:463
TFormula_v5.cxx:464
TFormula_v5.cxx:465
TFormula_v5.cxx:466
TFormula_v5.cxx:467
TFormula_v5.cxx:468
TFormula_v5.cxx:469
TFormula_v5.cxx:470
TFormula_v5.cxx:471
TFormula_v5.cxx:472
TFormula_v5.cxx:473
TFormula_v5.cxx:474
TFormula_v5.cxx:475
TFormula_v5.cxx:476
TFormula_v5.cxx:477
TFormula_v5.cxx:478
TFormula_v5.cxx:479
TFormula_v5.cxx:480
TFormula_v5.cxx:481
TFormula_v5.cxx:482
TFormula_v5.cxx:483
TFormula_v5.cxx:484
TFormula_v5.cxx:485
TFormula_v5.cxx:486
TFormula_v5.cxx:487
TFormula_v5.cxx:488
TFormula_v5.cxx:489
TFormula_v5.cxx:490
TFormula_v5.cxx:491
TFormula_v5.cxx:492
TFormula_v5.cxx:493
TFormula_v5.cxx:494
TFormula_v5.cxx:495
TFormula_v5.cxx:496
TFormula_v5.cxx:497
TFormula_v5.cxx:498
TFormula_v5.cxx:499
TFormula_v5.cxx:500
TFormula_v5.cxx:501
TFormula_v5.cxx:502
TFormula_v5.cxx:503
TFormula_v5.cxx:504
TFormula_v5.cxx:505
TFormula_v5.cxx:506
TFormula_v5.cxx:507
TFormula_v5.cxx:508
TFormula_v5.cxx:509
TFormula_v5.cxx:510
TFormula_v5.cxx:511
TFormula_v5.cxx:512
TFormula_v5.cxx:513
TFormula_v5.cxx:514
TFormula_v5.cxx:515
TFormula_v5.cxx:516
TFormula_v5.cxx:517
TFormula_v5.cxx:518
TFormula_v5.cxx:519
TFormula_v5.cxx:520
TFormula_v5.cxx:521
TFormula_v5.cxx:522
TFormula_v5.cxx:523
TFormula_v5.cxx:524
TFormula_v5.cxx:525
TFormula_v5.cxx:526
TFormula_v5.cxx:527
TFormula_v5.cxx:528
TFormula_v5.cxx:529
TFormula_v5.cxx:530
TFormula_v5.cxx:531
TFormula_v5.cxx:532
TFormula_v5.cxx:533
TFormula_v5.cxx:534
TFormula_v5.cxx:535
TFormula_v5.cxx:536
TFormula_v5.cxx:537
TFormula_v5.cxx:538
TFormula_v5.cxx:539
TFormula_v5.cxx:540
TFormula_v5.cxx:541
TFormula_v5.cxx:542
TFormula_v5.cxx:543
TFormula_v5.cxx:544
TFormula_v5.cxx:545
TFormula_v5.cxx:546
TFormula_v5.cxx:547
TFormula_v5.cxx:548
TFormula_v5.cxx:549
TFormula_v5.cxx:550
TFormula_v5.cxx:551
TFormula_v5.cxx:552
TFormula_v5.cxx:553
TFormula_v5.cxx:554
TFormula_v5.cxx:555
TFormula_v5.cxx:556
TFormula_v5.cxx:557
TFormula_v5.cxx:558
TFormula_v5.cxx:559
TFormula_v5.cxx:560
TFormula_v5.cxx:561
TFormula_v5.cxx:562
TFormula_v5.cxx:563
TFormula_v5.cxx:564
TFormula_v5.cxx:565
TFormula_v5.cxx:566
TFormula_v5.cxx:567
TFormula_v5.cxx:568
TFormula_v5.cxx:569
TFormula_v5.cxx:570
TFormula_v5.cxx:571
TFormula_v5.cxx:572
TFormula_v5.cxx:573
TFormula_v5.cxx:574
TFormula_v5.cxx:575
TFormula_v5.cxx:576
TFormula_v5.cxx:577
TFormula_v5.cxx:578
TFormula_v5.cxx:579
TFormula_v5.cxx:580
TFormula_v5.cxx:581
TFormula_v5.cxx:582
TFormula_v5.cxx:583
TFormula_v5.cxx:584
TFormula_v5.cxx:585
TFormula_v5.cxx:586
TFormula_v5.cxx:587
TFormula_v5.cxx:588
TFormula_v5.cxx:589
TFormula_v5.cxx:590
TFormula_v5.cxx:591
TFormula_v5.cxx:592
TFormula_v5.cxx:593
TFormula_v5.cxx:594
TFormula_v5.cxx:595
TFormula_v5.cxx:596
TFormula_v5.cxx:597
TFormula_v5.cxx:598
TFormula_v5.cxx:599
TFormula_v5.cxx:600
TFormula_v5.cxx:601
TFormula_v5.cxx:602
TFormula_v5.cxx:603
TFormula_v5.cxx:604
TFormula_v5.cxx:605
TFormula_v5.cxx:606
TFormula_v5.cxx:607
TFormula_v5.cxx:608
TFormula_v5.cxx:609
TFormula_v5.cxx:610
TFormula_v5.cxx:611
TFormula_v5.cxx:612
TFormula_v5.cxx:613
TFormula_v5.cxx:614
TFormula_v5.cxx:615
TFormula_v5.cxx:616
TFormula_v5.cxx:617
TFormula_v5.cxx:618
TFormula_v5.cxx:619
TFormula_v5.cxx:620
TFormula_v5.cxx:621
TFormula_v5.cxx:622
TFormula_v5.cxx:623
TFormula_v5.cxx:624
TFormula_v5.cxx:625
TFormula_v5.cxx:626
TFormula_v5.cxx:627
TFormula_v5.cxx:628
TFormula_v5.cxx:629
TFormula_v5.cxx:630
TFormula_v5.cxx:631
TFormula_v5.cxx:632
TFormula_v5.cxx:633
TFormula_v5.cxx:634
TFormula_v5.cxx:635
TFormula_v5.cxx:636
TFormula_v5.cxx:637
TFormula_v5.cxx:638
TFormula_v5.cxx:639
TFormula_v5.cxx:640
TFormula_v5.cxx:641
TFormula_v5.cxx:642
TFormula_v5.cxx:643
TFormula_v5.cxx:644
TFormula_v5.cxx:645
TFormula_v5.cxx:646
TFormula_v5.cxx:647
TFormula_v5.cxx:648
TFormula_v5.cxx:649
TFormula_v5.cxx:650
TFormula_v5.cxx:651
TFormula_v5.cxx:652
TFormula_v5.cxx:653
TFormula_v5.cxx:654
TFormula_v5.cxx:655
TFormula_v5.cxx:656
TFormula_v5.cxx:657
TFormula_v5.cxx:658
TFormula_v5.cxx:659
TFormula_v5.cxx:660
TFormula_v5.cxx:661
TFormula_v5.cxx:662
TFormula_v5.cxx:663
TFormula_v5.cxx:664
TFormula_v5.cxx:665
TFormula_v5.cxx:666
TFormula_v5.cxx:667
TFormula_v5.cxx:668
TFormula_v5.cxx:669
TFormula_v5.cxx:670
TFormula_v5.cxx:671
TFormula_v5.cxx:672
TFormula_v5.cxx:673
TFormula_v5.cxx:674
TFormula_v5.cxx:675
TFormula_v5.cxx:676
TFormula_v5.cxx:677
TFormula_v5.cxx:678
TFormula_v5.cxx:679
TFormula_v5.cxx:680
TFormula_v5.cxx:681
TFormula_v5.cxx:682
TFormula_v5.cxx:683
TFormula_v5.cxx:684
TFormula_v5.cxx:685
TFormula_v5.cxx:686
TFormula_v5.cxx:687
TFormula_v5.cxx:688
TFormula_v5.cxx:689
TFormula_v5.cxx:690
TFormula_v5.cxx:691
TFormula_v5.cxx:692
TFormula_v5.cxx:693
TFormula_v5.cxx:694
TFormula_v5.cxx:695
TFormula_v5.cxx:696
TFormula_v5.cxx:697
TFormula_v5.cxx:698
TFormula_v5.cxx:699
TFormula_v5.cxx:700
TFormula_v5.cxx:701
TFormula_v5.cxx:702
TFormula_v5.cxx:703
TFormula_v5.cxx:704
TFormula_v5.cxx:705
TFormula_v5.cxx:706
TFormula_v5.cxx:707
TFormula_v5.cxx:708
TFormula_v5.cxx:709
TFormula_v5.cxx:710
TFormula_v5.cxx:711
TFormula_v5.cxx:712
TFormula_v5.cxx:713
TFormula_v5.cxx:714
TFormula_v5.cxx:715
TFormula_v5.cxx:716
TFormula_v5.cxx:717
TFormula_v5.cxx:718
TFormula_v5.cxx:719
TFormula_v5.cxx:720
TFormula_v5.cxx:721
TFormula_v5.cxx:722
TFormula_v5.cxx:723
TFormula_v5.cxx:724
TFormula_v5.cxx:725
TFormula_v5.cxx:726
TFormula_v5.cxx:727
TFormula_v5.cxx:728
TFormula_v5.cxx:729
TFormula_v5.cxx:730
TFormula_v5.cxx:731
TFormula_v5.cxx:732
TFormula_v5.cxx:733
TFormula_v5.cxx:734
TFormula_v5.cxx:735
TFormula_v5.cxx:736
TFormula_v5.cxx:737
TFormula_v5.cxx:738
TFormula_v5.cxx:739
TFormula_v5.cxx:740
TFormula_v5.cxx:741
TFormula_v5.cxx:742
TFormula_v5.cxx:743
TFormula_v5.cxx:744
TFormula_v5.cxx:745
TFormula_v5.cxx:746
TFormula_v5.cxx:747
TFormula_v5.cxx:748
TFormula_v5.cxx:749
TFormula_v5.cxx:750
TFormula_v5.cxx:751
TFormula_v5.cxx:752
TFormula_v5.cxx:753
TFormula_v5.cxx:754
TFormula_v5.cxx:755
TFormula_v5.cxx:756
TFormula_v5.cxx:757
TFormula_v5.cxx:758
TFormula_v5.cxx:759
TFormula_v5.cxx:760
TFormula_v5.cxx:761
TFormula_v5.cxx:762
TFormula_v5.cxx:763
TFormula_v5.cxx:764
TFormula_v5.cxx:765
TFormula_v5.cxx:766
TFormula_v5.cxx:767
TFormula_v5.cxx:768
TFormula_v5.cxx:769
TFormula_v5.cxx:770
TFormula_v5.cxx:771
TFormula_v5.cxx:772
TFormula_v5.cxx:773
TFormula_v5.cxx:774
TFormula_v5.cxx:775
TFormula_v5.cxx:776
TFormula_v5.cxx:777
TFormula_v5.cxx:778
TFormula_v5.cxx:779
TFormula_v5.cxx:780
TFormula_v5.cxx:781
TFormula_v5.cxx:782
TFormula_v5.cxx:783
TFormula_v5.cxx:784
TFormula_v5.cxx:785
TFormula_v5.cxx:786
TFormula_v5.cxx:787
TFormula_v5.cxx:788
TFormula_v5.cxx:789
TFormula_v5.cxx:790
TFormula_v5.cxx:791
TFormula_v5.cxx:792
TFormula_v5.cxx:793
TFormula_v5.cxx:794
TFormula_v5.cxx:795
TFormula_v5.cxx:796
TFormula_v5.cxx:797
TFormula_v5.cxx:798
TFormula_v5.cxx:799
TFormula_v5.cxx:800
TFormula_v5.cxx:801
TFormula_v5.cxx:802
TFormula_v5.cxx:803
TFormula_v5.cxx:804
TFormula_v5.cxx:805
TFormula_v5.cxx:806
TFormula_v5.cxx:807
TFormula_v5.cxx:808
TFormula_v5.cxx:809
TFormula_v5.cxx:810
TFormula_v5.cxx:811
TFormula_v5.cxx:812
TFormula_v5.cxx:813
TFormula_v5.cxx:814
TFormula_v5.cxx:815
TFormula_v5.cxx:816
TFormula_v5.cxx:817
TFormula_v5.cxx:818
TFormula_v5.cxx:819
TFormula_v5.cxx:820
TFormula_v5.cxx:821
TFormula_v5.cxx:822
TFormula_v5.cxx:823
TFormula_v5.cxx:824
TFormula_v5.cxx:825
TFormula_v5.cxx:826
TFormula_v5.cxx:827
TFormula_v5.cxx:828
TFormula_v5.cxx:829
TFormula_v5.cxx:830
TFormula_v5.cxx:831
TFormula_v5.cxx:832
TFormula_v5.cxx:833
TFormula_v5.cxx:834
TFormula_v5.cxx:835
TFormula_v5.cxx:836
TFormula_v5.cxx:837
TFormula_v5.cxx:838
TFormula_v5.cxx:839
TFormula_v5.cxx:840
TFormula_v5.cxx:841
TFormula_v5.cxx:842
TFormula_v5.cxx:843
TFormula_v5.cxx:844
TFormula_v5.cxx:845
TFormula_v5.cxx:846
TFormula_v5.cxx:847
TFormula_v5.cxx:848
TFormula_v5.cxx:849
TFormula_v5.cxx:850
TFormula_v5.cxx:851
TFormula_v5.cxx:852
TFormula_v5.cxx:853
TFormula_v5.cxx:854
TFormula_v5.cxx:855
TFormula_v5.cxx:856
TFormula_v5.cxx:857
TFormula_v5.cxx:858
TFormula_v5.cxx:859
TFormula_v5.cxx:860
TFormula_v5.cxx:861
TFormula_v5.cxx:862
TFormula_v5.cxx:863
TFormula_v5.cxx:864
TFormula_v5.cxx:865
TFormula_v5.cxx:866
TFormula_v5.cxx:867
TFormula_v5.cxx:868
TFormula_v5.cxx:869
TFormula_v5.cxx:870
TFormula_v5.cxx:871
TFormula_v5.cxx:872
TFormula_v5.cxx:873
TFormula_v5.cxx:874
TFormula_v5.cxx:875
TFormula_v5.cxx:876
TFormula_v5.cxx:877
TFormula_v5.cxx:878
TFormula_v5.cxx:879
TFormula_v5.cxx:880
TFormula_v5.cxx:881
TFormula_v5.cxx:882
TFormula_v5.cxx:883
TFormula_v5.cxx:884
TFormula_v5.cxx:885
TFormula_v5.cxx:886
TFormula_v5.cxx:887
TFormula_v5.cxx:888
TFormula_v5.cxx:889
TFormula_v5.cxx:890
TFormula_v5.cxx:891
TFormula_v5.cxx:892
TFormula_v5.cxx:893
TFormula_v5.cxx:894
TFormula_v5.cxx:895
TFormula_v5.cxx:896
TFormula_v5.cxx:897
TFormula_v5.cxx:898
TFormula_v5.cxx:899
TFormula_v5.cxx:900
TFormula_v5.cxx:901
TFormula_v5.cxx:902
TFormula_v5.cxx:903
TFormula_v5.cxx:904
TFormula_v5.cxx:905
TFormula_v5.cxx:906
TFormula_v5.cxx:907
TFormula_v5.cxx:908
TFormula_v5.cxx:909
TFormula_v5.cxx:910
TFormula_v5.cxx:911
TFormula_v5.cxx:912
TFormula_v5.cxx:913
TFormula_v5.cxx:914
TFormula_v5.cxx:915
TFormula_v5.cxx:916
TFormula_v5.cxx:917
TFormula_v5.cxx:918
TFormula_v5.cxx:919
TFormula_v5.cxx:920
TFormula_v5.cxx:921
TFormula_v5.cxx:922
TFormula_v5.cxx:923
TFormula_v5.cxx:924
TFormula_v5.cxx:925
TFormula_v5.cxx:926
TFormula_v5.cxx:927
TFormula_v5.cxx:928
TFormula_v5.cxx:929
TFormula_v5.cxx:930
TFormula_v5.cxx:931
TFormula_v5.cxx:932
TFormula_v5.cxx:933
TFormula_v5.cxx:934
TFormula_v5.cxx:935
TFormula_v5.cxx:936
TFormula_v5.cxx:937
TFormula_v5.cxx:938
TFormula_v5.cxx:939
TFormula_v5.cxx:940
TFormula_v5.cxx:941
TFormula_v5.cxx:942
TFormula_v5.cxx:943
TFormula_v5.cxx:944
TFormula_v5.cxx:945
TFormula_v5.cxx:946
TFormula_v5.cxx:947
TFormula_v5.cxx:948
TFormula_v5.cxx:949
TFormula_v5.cxx:950
TFormula_v5.cxx:951
TFormula_v5.cxx:952
TFormula_v5.cxx:953
TFormula_v5.cxx:954
TFormula_v5.cxx:955
TFormula_v5.cxx:956
TFormula_v5.cxx:957
TFormula_v5.cxx:958
TFormula_v5.cxx:959
TFormula_v5.cxx:960
TFormula_v5.cxx:961
TFormula_v5.cxx:962
TFormula_v5.cxx:963
TFormula_v5.cxx:964
TFormula_v5.cxx:965
TFormula_v5.cxx:966
TFormula_v5.cxx:967
TFormula_v5.cxx:968
TFormula_v5.cxx:969
TFormula_v5.cxx:970
TFormula_v5.cxx:971
TFormula_v5.cxx:972
TFormula_v5.cxx:973
TFormula_v5.cxx:974
TFormula_v5.cxx:975
TFormula_v5.cxx:976
TFormula_v5.cxx:977
TFormula_v5.cxx:978
TFormula_v5.cxx:979
TFormula_v5.cxx:980
TFormula_v5.cxx:981
TFormula_v5.cxx:982
TFormula_v5.cxx:983
TFormula_v5.cxx:984
TFormula_v5.cxx:985
TFormula_v5.cxx:986
TFormula_v5.cxx:987
TFormula_v5.cxx:988
TFormula_v5.cxx:989
TFormula_v5.cxx:990
TFormula_v5.cxx:991
TFormula_v5.cxx:992
TFormula_v5.cxx:993
TFormula_v5.cxx:994
TFormula_v5.cxx:995
TFormula_v5.cxx:996
TFormula_v5.cxx:997
TFormula_v5.cxx:998
TFormula_v5.cxx:999
TFormula_v5.cxx:1000
TFormula_v5.cxx:1001
TFormula_v5.cxx:1002
TFormula_v5.cxx:1003
TFormula_v5.cxx:1004
TFormula_v5.cxx:1005
TFormula_v5.cxx:1006
TFormula_v5.cxx:1007
TFormula_v5.cxx:1008
TFormula_v5.cxx:1009
TFormula_v5.cxx:1010
TFormula_v5.cxx:1011
TFormula_v5.cxx:1012
TFormula_v5.cxx:1013
TFormula_v5.cxx:1014
TFormula_v5.cxx:1015
TFormula_v5.cxx:1016
TFormula_v5.cxx:1017
TFormula_v5.cxx:1018
TFormula_v5.cxx:1019
TFormula_v5.cxx:1020
TFormula_v5.cxx:1021
TFormula_v5.cxx:1022
TFormula_v5.cxx:1023
TFormula_v5.cxx:1024
TFormula_v5.cxx:1025
TFormula_v5.cxx:1026
TFormula_v5.cxx:1027
TFormula_v5.cxx:1028
TFormula_v5.cxx:1029
TFormula_v5.cxx:1030
TFormula_v5.cxx:1031
TFormula_v5.cxx:1032
TFormula_v5.cxx:1033
TFormula_v5.cxx:1034
TFormula_v5.cxx:1035
TFormula_v5.cxx:1036
TFormula_v5.cxx:1037
TFormula_v5.cxx:1038
TFormula_v5.cxx:1039
TFormula_v5.cxx:1040
TFormula_v5.cxx:1041
TFormula_v5.cxx:1042
TFormula_v5.cxx:1043
TFormula_v5.cxx:1044
TFormula_v5.cxx:1045
TFormula_v5.cxx:1046
TFormula_v5.cxx:1047
TFormula_v5.cxx:1048
TFormula_v5.cxx:1049
TFormula_v5.cxx:1050
TFormula_v5.cxx:1051
TFormula_v5.cxx:1052
TFormula_v5.cxx:1053
TFormula_v5.cxx:1054
TFormula_v5.cxx:1055
TFormula_v5.cxx:1056
TFormula_v5.cxx:1057
TFormula_v5.cxx:1058
TFormula_v5.cxx:1059
TFormula_v5.cxx:1060
TFormula_v5.cxx:1061
TFormula_v5.cxx:1062
TFormula_v5.cxx:1063
TFormula_v5.cxx:1064
TFormula_v5.cxx:1065
TFormula_v5.cxx:1066
TFormula_v5.cxx:1067
TFormula_v5.cxx:1068
TFormula_v5.cxx:1069
TFormula_v5.cxx:1070
TFormula_v5.cxx:1071
TFormula_v5.cxx:1072
TFormula_v5.cxx:1073
TFormula_v5.cxx:1074
TFormula_v5.cxx:1075
TFormula_v5.cxx:1076
TFormula_v5.cxx:1077
TFormula_v5.cxx:1078
TFormula_v5.cxx:1079
TFormula_v5.cxx:1080
TFormula_v5.cxx:1081
TFormula_v5.cxx:1082
TFormula_v5.cxx:1083
TFormula_v5.cxx:1084
TFormula_v5.cxx:1085
TFormula_v5.cxx:1086
TFormula_v5.cxx:1087
TFormula_v5.cxx:1088
TFormula_v5.cxx:1089
TFormula_v5.cxx:1090
TFormula_v5.cxx:1091
TFormula_v5.cxx:1092
TFormula_v5.cxx:1093
TFormula_v5.cxx:1094
TFormula_v5.cxx:1095
TFormula_v5.cxx:1096
TFormula_v5.cxx:1097
TFormula_v5.cxx:1098
TFormula_v5.cxx:1099
TFormula_v5.cxx:1100
TFormula_v5.cxx:1101
TFormula_v5.cxx:1102
TFormula_v5.cxx:1103
TFormula_v5.cxx:1104
TFormula_v5.cxx:1105
TFormula_v5.cxx:1106
TFormula_v5.cxx:1107
TFormula_v5.cxx:1108
TFormula_v5.cxx:1109
TFormula_v5.cxx:1110
TFormula_v5.cxx:1111
TFormula_v5.cxx:1112
TFormula_v5.cxx:1113
TFormula_v5.cxx:1114
TFormula_v5.cxx:1115
TFormula_v5.cxx:1116
TFormula_v5.cxx:1117
TFormula_v5.cxx:1118
TFormula_v5.cxx:1119
TFormula_v5.cxx:1120
TFormula_v5.cxx:1121
TFormula_v5.cxx:1122
TFormula_v5.cxx:1123
TFormula_v5.cxx:1124
TFormula_v5.cxx:1125
TFormula_v5.cxx:1126
TFormula_v5.cxx:1127
TFormula_v5.cxx:1128
TFormula_v5.cxx:1129
TFormula_v5.cxx:1130
TFormula_v5.cxx:1131
TFormula_v5.cxx:1132
TFormula_v5.cxx:1133
TFormula_v5.cxx:1134
TFormula_v5.cxx:1135
TFormula_v5.cxx:1136
TFormula_v5.cxx:1137
TFormula_v5.cxx:1138
TFormula_v5.cxx:1139
TFormula_v5.cxx:1140
TFormula_v5.cxx:1141
TFormula_v5.cxx:1142
TFormula_v5.cxx:1143
TFormula_v5.cxx:1144
TFormula_v5.cxx:1145
TFormula_v5.cxx:1146
TFormula_v5.cxx:1147
TFormula_v5.cxx:1148
TFormula_v5.cxx:1149
TFormula_v5.cxx:1150
TFormula_v5.cxx:1151
TFormula_v5.cxx:1152
TFormula_v5.cxx:1153
TFormula_v5.cxx:1154
TFormula_v5.cxx:1155
TFormula_v5.cxx:1156
TFormula_v5.cxx:1157
TFormula_v5.cxx:1158
TFormula_v5.cxx:1159
TFormula_v5.cxx:1160
TFormula_v5.cxx:1161
TFormula_v5.cxx:1162
TFormula_v5.cxx:1163
TFormula_v5.cxx:1164
TFormula_v5.cxx:1165
TFormula_v5.cxx:1166
TFormula_v5.cxx:1167
TFormula_v5.cxx:1168
TFormula_v5.cxx:1169
TFormula_v5.cxx:1170
TFormula_v5.cxx:1171
TFormula_v5.cxx:1172
TFormula_v5.cxx:1173
TFormula_v5.cxx:1174
TFormula_v5.cxx:1175
TFormula_v5.cxx:1176
TFormula_v5.cxx:1177
TFormula_v5.cxx:1178
TFormula_v5.cxx:1179
TFormula_v5.cxx:1180
TFormula_v5.cxx:1181
TFormula_v5.cxx:1182
TFormula_v5.cxx:1183
TFormula_v5.cxx:1184
TFormula_v5.cxx:1185
TFormula_v5.cxx:1186
TFormula_v5.cxx:1187
TFormula_v5.cxx:1188
TFormula_v5.cxx:1189
TFormula_v5.cxx:1190
TFormula_v5.cxx:1191
TFormula_v5.cxx:1192
TFormula_v5.cxx:1193
TFormula_v5.cxx:1194
TFormula_v5.cxx:1195
TFormula_v5.cxx:1196
TFormula_v5.cxx:1197
TFormula_v5.cxx:1198
TFormula_v5.cxx:1199
TFormula_v5.cxx:1200
TFormula_v5.cxx:1201
TFormula_v5.cxx:1202
TFormula_v5.cxx:1203
TFormula_v5.cxx:1204
TFormula_v5.cxx:1205
TFormula_v5.cxx:1206
TFormula_v5.cxx:1207
TFormula_v5.cxx:1208
TFormula_v5.cxx:1209
TFormula_v5.cxx:1210
TFormula_v5.cxx:1211
TFormula_v5.cxx:1212
TFormula_v5.cxx:1213
TFormula_v5.cxx:1214
TFormula_v5.cxx:1215
TFormula_v5.cxx:1216
TFormula_v5.cxx:1217
TFormula_v5.cxx:1218
TFormula_v5.cxx:1219
TFormula_v5.cxx:1220
TFormula_v5.cxx:1221
TFormula_v5.cxx:1222
TFormula_v5.cxx:1223
TFormula_v5.cxx:1224
TFormula_v5.cxx:1225
TFormula_v5.cxx:1226
TFormula_v5.cxx:1227
TFormula_v5.cxx:1228
TFormula_v5.cxx:1229
TFormula_v5.cxx:1230
TFormula_v5.cxx:1231
TFormula_v5.cxx:1232
TFormula_v5.cxx:1233
TFormula_v5.cxx:1234
TFormula_v5.cxx:1235
TFormula_v5.cxx:1236
TFormula_v5.cxx:1237
TFormula_v5.cxx:1238
TFormula_v5.cxx:1239
TFormula_v5.cxx:1240
TFormula_v5.cxx:1241
TFormula_v5.cxx:1242
TFormula_v5.cxx:1243
TFormula_v5.cxx:1244
TFormula_v5.cxx:1245
TFormula_v5.cxx:1246
TFormula_v5.cxx:1247
TFormula_v5.cxx:1248
TFormula_v5.cxx:1249
TFormula_v5.cxx:1250
TFormula_v5.cxx:1251
TFormula_v5.cxx:1252
TFormula_v5.cxx:1253
TFormula_v5.cxx:1254
TFormula_v5.cxx:1255
TFormula_v5.cxx:1256
TFormula_v5.cxx:1257
TFormula_v5.cxx:1258
TFormula_v5.cxx:1259
TFormula_v5.cxx:1260
TFormula_v5.cxx:1261
TFormula_v5.cxx:1262
TFormula_v5.cxx:1263
TFormula_v5.cxx:1264
TFormula_v5.cxx:1265
TFormula_v5.cxx:1266
TFormula_v5.cxx:1267
TFormula_v5.cxx:1268
TFormula_v5.cxx:1269
TFormula_v5.cxx:1270
TFormula_v5.cxx:1271
TFormula_v5.cxx:1272
TFormula_v5.cxx:1273
TFormula_v5.cxx:1274
TFormula_v5.cxx:1275
TFormula_v5.cxx:1276
TFormula_v5.cxx:1277
TFormula_v5.cxx:1278
TFormula_v5.cxx:1279
TFormula_v5.cxx:1280
TFormula_v5.cxx:1281
TFormula_v5.cxx:1282
TFormula_v5.cxx:1283
TFormula_v5.cxx:1284
TFormula_v5.cxx:1285
TFormula_v5.cxx:1286
TFormula_v5.cxx:1287
TFormula_v5.cxx:1288
TFormula_v5.cxx:1289
TFormula_v5.cxx:1290
TFormula_v5.cxx:1291
TFormula_v5.cxx:1292
TFormula_v5.cxx:1293
TFormula_v5.cxx:1294
TFormula_v5.cxx:1295
TFormula_v5.cxx:1296
TFormula_v5.cxx:1297
TFormula_v5.cxx:1298
TFormula_v5.cxx:1299
TFormula_v5.cxx:1300
TFormula_v5.cxx:1301
TFormula_v5.cxx:1302
TFormula_v5.cxx:1303
TFormula_v5.cxx:1304
TFormula_v5.cxx:1305
TFormula_v5.cxx:1306
TFormula_v5.cxx:1307
TFormula_v5.cxx:1308
TFormula_v5.cxx:1309
TFormula_v5.cxx:1310
TFormula_v5.cxx:1311
TFormula_v5.cxx:1312
TFormula_v5.cxx:1313
TFormula_v5.cxx:1314
TFormula_v5.cxx:1315
TFormula_v5.cxx:1316
TFormula_v5.cxx:1317
TFormula_v5.cxx:1318
TFormula_v5.cxx:1319
TFormula_v5.cxx:1320
TFormula_v5.cxx:1321
TFormula_v5.cxx:1322
TFormula_v5.cxx:1323
TFormula_v5.cxx:1324
TFormula_v5.cxx:1325
TFormula_v5.cxx:1326
TFormula_v5.cxx:1327
TFormula_v5.cxx:1328
TFormula_v5.cxx:1329
TFormula_v5.cxx:1330
TFormula_v5.cxx:1331
TFormula_v5.cxx:1332
TFormula_v5.cxx:1333
TFormula_v5.cxx:1334
TFormula_v5.cxx:1335
TFormula_v5.cxx:1336
TFormula_v5.cxx:1337
TFormula_v5.cxx:1338
TFormula_v5.cxx:1339
TFormula_v5.cxx:1340
TFormula_v5.cxx:1341
TFormula_v5.cxx:1342
TFormula_v5.cxx:1343
TFormula_v5.cxx:1344
TFormula_v5.cxx:1345
TFormula_v5.cxx:1346
TFormula_v5.cxx:1347
TFormula_v5.cxx:1348
TFormula_v5.cxx:1349
TFormula_v5.cxx:1350
TFormula_v5.cxx:1351
TFormula_v5.cxx:1352
TFormula_v5.cxx:1353
TFormula_v5.cxx:1354
TFormula_v5.cxx:1355
TFormula_v5.cxx:1356
TFormula_v5.cxx:1357
TFormula_v5.cxx:1358
TFormula_v5.cxx:1359
TFormula_v5.cxx:1360
TFormula_v5.cxx:1361
TFormula_v5.cxx:1362
TFormula_v5.cxx:1363
TFormula_v5.cxx:1364
TFormula_v5.cxx:1365
TFormula_v5.cxx:1366
TFormula_v5.cxx:1367
TFormula_v5.cxx:1368
TFormula_v5.cxx:1369
TFormula_v5.cxx:1370
TFormula_v5.cxx:1371
TFormula_v5.cxx:1372
TFormula_v5.cxx:1373
TFormula_v5.cxx:1374
TFormula_v5.cxx:1375
TFormula_v5.cxx:1376
TFormula_v5.cxx:1377
TFormula_v5.cxx:1378
TFormula_v5.cxx:1379
TFormula_v5.cxx:1380
TFormula_v5.cxx:1381
TFormula_v5.cxx:1382
TFormula_v5.cxx:1383
TFormula_v5.cxx:1384
TFormula_v5.cxx:1385
TFormula_v5.cxx:1386
TFormula_v5.cxx:1387
TFormula_v5.cxx:1388
TFormula_v5.cxx:1389
TFormula_v5.cxx:1390
TFormula_v5.cxx:1391
TFormula_v5.cxx:1392
TFormula_v5.cxx:1393
TFormula_v5.cxx:1394
TFormula_v5.cxx:1395
TFormula_v5.cxx:1396
TFormula_v5.cxx:1397
TFormula_v5.cxx:1398
TFormula_v5.cxx:1399
TFormula_v5.cxx:1400
TFormula_v5.cxx:1401
TFormula_v5.cxx:1402
TFormula_v5.cxx:1403
TFormula_v5.cxx:1404
TFormula_v5.cxx:1405
TFormula_v5.cxx:1406
TFormula_v5.cxx:1407
TFormula_v5.cxx:1408
TFormula_v5.cxx:1409
TFormula_v5.cxx:1410
TFormula_v5.cxx:1411
TFormula_v5.cxx:1412
TFormula_v5.cxx:1413
TFormula_v5.cxx:1414
TFormula_v5.cxx:1415
TFormula_v5.cxx:1416
TFormula_v5.cxx:1417
TFormula_v5.cxx:1418
TFormula_v5.cxx:1419
TFormula_v5.cxx:1420
TFormula_v5.cxx:1421
TFormula_v5.cxx:1422
TFormula_v5.cxx:1423
TFormula_v5.cxx:1424
TFormula_v5.cxx:1425
TFormula_v5.cxx:1426
TFormula_v5.cxx:1427
TFormula_v5.cxx:1428
TFormula_v5.cxx:1429
TFormula_v5.cxx:1430
TFormula_v5.cxx:1431
TFormula_v5.cxx:1432
TFormula_v5.cxx:1433
TFormula_v5.cxx:1434
TFormula_v5.cxx:1435
TFormula_v5.cxx:1436
TFormula_v5.cxx:1437
TFormula_v5.cxx:1438
TFormula_v5.cxx:1439
TFormula_v5.cxx:1440
TFormula_v5.cxx:1441
TFormula_v5.cxx:1442
TFormula_v5.cxx:1443
TFormula_v5.cxx:1444
TFormula_v5.cxx:1445
TFormula_v5.cxx:1446
TFormula_v5.cxx:1447
TFormula_v5.cxx:1448
TFormula_v5.cxx:1449
TFormula_v5.cxx:1450
TFormula_v5.cxx:1451
TFormula_v5.cxx:1452
TFormula_v5.cxx:1453
TFormula_v5.cxx:1454
TFormula_v5.cxx:1455
TFormula_v5.cxx:1456
TFormula_v5.cxx:1457
TFormula_v5.cxx:1458
TFormula_v5.cxx:1459
TFormula_v5.cxx:1460
TFormula_v5.cxx:1461
TFormula_v5.cxx:1462
TFormula_v5.cxx:1463
TFormula_v5.cxx:1464
TFormula_v5.cxx:1465
TFormula_v5.cxx:1466
TFormula_v5.cxx:1467
TFormula_v5.cxx:1468
TFormula_v5.cxx:1469
TFormula_v5.cxx:1470
TFormula_v5.cxx:1471
TFormula_v5.cxx:1472
TFormula_v5.cxx:1473
TFormula_v5.cxx:1474
TFormula_v5.cxx:1475
TFormula_v5.cxx:1476
TFormula_v5.cxx:1477
TFormula_v5.cxx:1478
TFormula_v5.cxx:1479
TFormula_v5.cxx:1480
TFormula_v5.cxx:1481
TFormula_v5.cxx:1482
TFormula_v5.cxx:1483
TFormula_v5.cxx:1484
TFormula_v5.cxx:1485
TFormula_v5.cxx:1486
TFormula_v5.cxx:1487
TFormula_v5.cxx:1488
TFormula_v5.cxx:1489
TFormula_v5.cxx:1490
TFormula_v5.cxx:1491
TFormula_v5.cxx:1492
TFormula_v5.cxx:1493
TFormula_v5.cxx:1494
TFormula_v5.cxx:1495
TFormula_v5.cxx:1496
TFormula_v5.cxx:1497
TFormula_v5.cxx:1498
TFormula_v5.cxx:1499
TFormula_v5.cxx:1500
TFormula_v5.cxx:1501
TFormula_v5.cxx:1502
TFormula_v5.cxx:1503
TFormula_v5.cxx:1504
TFormula_v5.cxx:1505
TFormula_v5.cxx:1506
TFormula_v5.cxx:1507
TFormula_v5.cxx:1508
TFormula_v5.cxx:1509
TFormula_v5.cxx:1510
TFormula_v5.cxx:1511
TFormula_v5.cxx:1512
TFormula_v5.cxx:1513
TFormula_v5.cxx:1514
TFormula_v5.cxx:1515
TFormula_v5.cxx:1516
TFormula_v5.cxx:1517
TFormula_v5.cxx:1518
TFormula_v5.cxx:1519
TFormula_v5.cxx:1520
TFormula_v5.cxx:1521
TFormula_v5.cxx:1522
TFormula_v5.cxx:1523
TFormula_v5.cxx:1524
TFormula_v5.cxx:1525
TFormula_v5.cxx:1526
TFormula_v5.cxx:1527
TFormula_v5.cxx:1528
TFormula_v5.cxx:1529
TFormula_v5.cxx:1530
TFormula_v5.cxx:1531
TFormula_v5.cxx:1532
TFormula_v5.cxx:1533
TFormula_v5.cxx:1534
TFormula_v5.cxx:1535
TFormula_v5.cxx:1536
TFormula_v5.cxx:1537
TFormula_v5.cxx:1538
TFormula_v5.cxx:1539
TFormula_v5.cxx:1540
TFormula_v5.cxx:1541
TFormula_v5.cxx:1542
TFormula_v5.cxx:1543
TFormula_v5.cxx:1544
TFormula_v5.cxx:1545
TFormula_v5.cxx:1546
TFormula_v5.cxx:1547
TFormula_v5.cxx:1548
TFormula_v5.cxx:1549
TFormula_v5.cxx:1550
TFormula_v5.cxx:1551
TFormula_v5.cxx:1552
TFormula_v5.cxx:1553
TFormula_v5.cxx:1554
TFormula_v5.cxx:1555
TFormula_v5.cxx:1556
TFormula_v5.cxx:1557
TFormula_v5.cxx:1558
TFormula_v5.cxx:1559
TFormula_v5.cxx:1560
TFormula_v5.cxx:1561
TFormula_v5.cxx:1562
TFormula_v5.cxx:1563
TFormula_v5.cxx:1564
TFormula_v5.cxx:1565
TFormula_v5.cxx:1566
TFormula_v5.cxx:1567
TFormula_v5.cxx:1568
TFormula_v5.cxx:1569
TFormula_v5.cxx:1570
TFormula_v5.cxx:1571
TFormula_v5.cxx:1572
TFormula_v5.cxx:1573
TFormula_v5.cxx:1574
TFormula_v5.cxx:1575
TFormula_v5.cxx:1576
TFormula_v5.cxx:1577
TFormula_v5.cxx:1578
TFormula_v5.cxx:1579
TFormula_v5.cxx:1580
TFormula_v5.cxx:1581
TFormula_v5.cxx:1582
TFormula_v5.cxx:1583
TFormula_v5.cxx:1584
TFormula_v5.cxx:1585
TFormula_v5.cxx:1586
TFormula_v5.cxx:1587
TFormula_v5.cxx:1588
TFormula_v5.cxx:1589
TFormula_v5.cxx:1590
TFormula_v5.cxx:1591
TFormula_v5.cxx:1592
TFormula_v5.cxx:1593
TFormula_v5.cxx:1594
TFormula_v5.cxx:1595
TFormula_v5.cxx:1596
TFormula_v5.cxx:1597
TFormula_v5.cxx:1598
TFormula_v5.cxx:1599
TFormula_v5.cxx:1600
TFormula_v5.cxx:1601
TFormula_v5.cxx:1602
TFormula_v5.cxx:1603
TFormula_v5.cxx:1604
TFormula_v5.cxx:1605
TFormula_v5.cxx:1606
TFormula_v5.cxx:1607
TFormula_v5.cxx:1608
TFormula_v5.cxx:1609
TFormula_v5.cxx:1610
TFormula_v5.cxx:1611
TFormula_v5.cxx:1612
TFormula_v5.cxx:1613
TFormula_v5.cxx:1614
TFormula_v5.cxx:1615
TFormula_v5.cxx:1616
TFormula_v5.cxx:1617
TFormula_v5.cxx:1618
TFormula_v5.cxx:1619
TFormula_v5.cxx:1620
TFormula_v5.cxx:1621
TFormula_v5.cxx:1622
TFormula_v5.cxx:1623
TFormula_v5.cxx:1624
TFormula_v5.cxx:1625
TFormula_v5.cxx:1626
TFormula_v5.cxx:1627
TFormula_v5.cxx:1628
TFormula_v5.cxx:1629
TFormula_v5.cxx:1630
TFormula_v5.cxx:1631
TFormula_v5.cxx:1632
TFormula_v5.cxx:1633
TFormula_v5.cxx:1634
TFormula_v5.cxx:1635
TFormula_v5.cxx:1636
TFormula_v5.cxx:1637
TFormula_v5.cxx:1638
TFormula_v5.cxx:1639
TFormula_v5.cxx:1640
TFormula_v5.cxx:1641
TFormula_v5.cxx:1642
TFormula_v5.cxx:1643
TFormula_v5.cxx:1644
TFormula_v5.cxx:1645
TFormula_v5.cxx:1646
TFormula_v5.cxx:1647
TFormula_v5.cxx:1648
TFormula_v5.cxx:1649
TFormula_v5.cxx:1650
TFormula_v5.cxx:1651
TFormula_v5.cxx:1652
TFormula_v5.cxx:1653
TFormula_v5.cxx:1654
TFormula_v5.cxx:1655
TFormula_v5.cxx:1656
TFormula_v5.cxx:1657
TFormula_v5.cxx:1658
TFormula_v5.cxx:1659
TFormula_v5.cxx:1660
TFormula_v5.cxx:1661
TFormula_v5.cxx:1662
TFormula_v5.cxx:1663
TFormula_v5.cxx:1664
TFormula_v5.cxx:1665
TFormula_v5.cxx:1666
TFormula_v5.cxx:1667
TFormula_v5.cxx:1668
TFormula_v5.cxx:1669
TFormula_v5.cxx:1670
TFormula_v5.cxx:1671
TFormula_v5.cxx:1672
TFormula_v5.cxx:1673
TFormula_v5.cxx:1674
TFormula_v5.cxx:1675
TFormula_v5.cxx:1676
TFormula_v5.cxx:1677
TFormula_v5.cxx:1678
TFormula_v5.cxx:1679
TFormula_v5.cxx:1680
TFormula_v5.cxx:1681
TFormula_v5.cxx:1682
TFormula_v5.cxx:1683
TFormula_v5.cxx:1684
TFormula_v5.cxx:1685
TFormula_v5.cxx:1686
TFormula_v5.cxx:1687
TFormula_v5.cxx:1688
TFormula_v5.cxx:1689
TFormula_v5.cxx:1690
TFormula_v5.cxx:1691
TFormula_v5.cxx:1692
TFormula_v5.cxx:1693
TFormula_v5.cxx:1694
TFormula_v5.cxx:1695
TFormula_v5.cxx:1696
TFormula_v5.cxx:1697
TFormula_v5.cxx:1698
TFormula_v5.cxx:1699
TFormula_v5.cxx:1700
TFormula_v5.cxx:1701
TFormula_v5.cxx:1702
TFormula_v5.cxx:1703
TFormula_v5.cxx:1704
TFormula_v5.cxx:1705
TFormula_v5.cxx:1706
TFormula_v5.cxx:1707
TFormula_v5.cxx:1708
TFormula_v5.cxx:1709
TFormula_v5.cxx:1710
TFormula_v5.cxx:1711
TFormula_v5.cxx:1712
TFormula_v5.cxx:1713
TFormula_v5.cxx:1714
TFormula_v5.cxx:1715
TFormula_v5.cxx:1716
TFormula_v5.cxx:1717
TFormula_v5.cxx:1718
TFormula_v5.cxx:1719
TFormula_v5.cxx:1720
TFormula_v5.cxx:1721
TFormula_v5.cxx:1722
TFormula_v5.cxx:1723
TFormula_v5.cxx:1724
TFormula_v5.cxx:1725
TFormula_v5.cxx:1726
TFormula_v5.cxx:1727
TFormula_v5.cxx:1728
TFormula_v5.cxx:1729
TFormula_v5.cxx:1730
TFormula_v5.cxx:1731
TFormula_v5.cxx:1732
TFormula_v5.cxx:1733
TFormula_v5.cxx:1734
TFormula_v5.cxx:1735
TFormula_v5.cxx:1736
TFormula_v5.cxx:1737
TFormula_v5.cxx:1738
TFormula_v5.cxx:1739
TFormula_v5.cxx:1740
TFormula_v5.cxx:1741
TFormula_v5.cxx:1742
TFormula_v5.cxx:1743
TFormula_v5.cxx:1744
TFormula_v5.cxx:1745
TFormula_v5.cxx:1746
TFormula_v5.cxx:1747
TFormula_v5.cxx:1748
TFormula_v5.cxx:1749
TFormula_v5.cxx:1750
TFormula_v5.cxx:1751
TFormula_v5.cxx:1752
TFormula_v5.cxx:1753
TFormula_v5.cxx:1754
TFormula_v5.cxx:1755
TFormula_v5.cxx:1756
TFormula_v5.cxx:1757
TFormula_v5.cxx:1758
TFormula_v5.cxx:1759
TFormula_v5.cxx:1760
TFormula_v5.cxx:1761
TFormula_v5.cxx:1762
TFormula_v5.cxx:1763
TFormula_v5.cxx:1764
TFormula_v5.cxx:1765
TFormula_v5.cxx:1766
TFormula_v5.cxx:1767
TFormula_v5.cxx:1768
TFormula_v5.cxx:1769
TFormula_v5.cxx:1770
TFormula_v5.cxx:1771
TFormula_v5.cxx:1772
TFormula_v5.cxx:1773
TFormula_v5.cxx:1774
TFormula_v5.cxx:1775
TFormula_v5.cxx:1776
TFormula_v5.cxx:1777
TFormula_v5.cxx:1778
TFormula_v5.cxx:1779
TFormula_v5.cxx:1780
TFormula_v5.cxx:1781
TFormula_v5.cxx:1782
TFormula_v5.cxx:1783
TFormula_v5.cxx:1784
TFormula_v5.cxx:1785
TFormula_v5.cxx:1786
TFormula_v5.cxx:1787
TFormula_v5.cxx:1788
TFormula_v5.cxx:1789
TFormula_v5.cxx:1790
TFormula_v5.cxx:1791
TFormula_v5.cxx:1792
TFormula_v5.cxx:1793
TFormula_v5.cxx:1794
TFormula_v5.cxx:1795
TFormula_v5.cxx:1796
TFormula_v5.cxx:1797
TFormula_v5.cxx:1798
TFormula_v5.cxx:1799
TFormula_v5.cxx:1800
TFormula_v5.cxx:1801
TFormula_v5.cxx:1802
TFormula_v5.cxx:1803
TFormula_v5.cxx:1804
TFormula_v5.cxx:1805
TFormula_v5.cxx:1806
TFormula_v5.cxx:1807
TFormula_v5.cxx:1808
TFormula_v5.cxx:1809
TFormula_v5.cxx:1810
TFormula_v5.cxx:1811
TFormula_v5.cxx:1812
TFormula_v5.cxx:1813
TFormula_v5.cxx:1814
TFormula_v5.cxx:1815
TFormula_v5.cxx:1816
TFormula_v5.cxx:1817
TFormula_v5.cxx:1818
TFormula_v5.cxx:1819
TFormula_v5.cxx:1820
TFormula_v5.cxx:1821
TFormula_v5.cxx:1822
TFormula_v5.cxx:1823
TFormula_v5.cxx:1824
TFormula_v5.cxx:1825
TFormula_v5.cxx:1826
TFormula_v5.cxx:1827
TFormula_v5.cxx:1828
TFormula_v5.cxx:1829
TFormula_v5.cxx:1830
TFormula_v5.cxx:1831
TFormula_v5.cxx:1832
TFormula_v5.cxx:1833
TFormula_v5.cxx:1834
TFormula_v5.cxx:1835
TFormula_v5.cxx:1836
TFormula_v5.cxx:1837
TFormula_v5.cxx:1838
TFormula_v5.cxx:1839
TFormula_v5.cxx:1840
TFormula_v5.cxx:1841
TFormula_v5.cxx:1842
TFormula_v5.cxx:1843
TFormula_v5.cxx:1844
TFormula_v5.cxx:1845
TFormula_v5.cxx:1846
TFormula_v5.cxx:1847
TFormula_v5.cxx:1848
TFormula_v5.cxx:1849
TFormula_v5.cxx:1850
TFormula_v5.cxx:1851
TFormula_v5.cxx:1852
TFormula_v5.cxx:1853
TFormula_v5.cxx:1854
TFormula_v5.cxx:1855
TFormula_v5.cxx:1856
TFormula_v5.cxx:1857
TFormula_v5.cxx:1858
TFormula_v5.cxx:1859
TFormula_v5.cxx:1860
TFormula_v5.cxx:1861
TFormula_v5.cxx:1862
TFormula_v5.cxx:1863
TFormula_v5.cxx:1864
TFormula_v5.cxx:1865
TFormula_v5.cxx:1866
TFormula_v5.cxx:1867
TFormula_v5.cxx:1868
TFormula_v5.cxx:1869
TFormula_v5.cxx:1870
TFormula_v5.cxx:1871
TFormula_v5.cxx:1872
TFormula_v5.cxx:1873
TFormula_v5.cxx:1874
TFormula_v5.cxx:1875
TFormula_v5.cxx:1876
TFormula_v5.cxx:1877
TFormula_v5.cxx:1878
TFormula_v5.cxx:1879
TFormula_v5.cxx:1880
TFormula_v5.cxx:1881
TFormula_v5.cxx:1882
TFormula_v5.cxx:1883
TFormula_v5.cxx:1884
TFormula_v5.cxx:1885
TFormula_v5.cxx:1886
TFormula_v5.cxx:1887
TFormula_v5.cxx:1888
TFormula_v5.cxx:1889
TFormula_v5.cxx:1890
TFormula_v5.cxx:1891
TFormula_v5.cxx:1892
TFormula_v5.cxx:1893
TFormula_v5.cxx:1894
TFormula_v5.cxx:1895
TFormula_v5.cxx:1896
TFormula_v5.cxx:1897
TFormula_v5.cxx:1898
TFormula_v5.cxx:1899
TFormula_v5.cxx:1900
TFormula_v5.cxx:1901
TFormula_v5.cxx:1902
TFormula_v5.cxx:1903
TFormula_v5.cxx:1904
TFormula_v5.cxx:1905
TFormula_v5.cxx:1906
TFormula_v5.cxx:1907
TFormula_v5.cxx:1908
TFormula_v5.cxx:1909
TFormula_v5.cxx:1910
TFormula_v5.cxx:1911
TFormula_v5.cxx:1912
TFormula_v5.cxx:1913
TFormula_v5.cxx:1914
TFormula_v5.cxx:1915
TFormula_v5.cxx:1916
TFormula_v5.cxx:1917
TFormula_v5.cxx:1918
TFormula_v5.cxx:1919
TFormula_v5.cxx:1920
TFormula_v5.cxx:1921
TFormula_v5.cxx:1922
TFormula_v5.cxx:1923
TFormula_v5.cxx:1924
TFormula_v5.cxx:1925
TFormula_v5.cxx:1926
TFormula_v5.cxx:1927
TFormula_v5.cxx:1928
TFormula_v5.cxx:1929
TFormula_v5.cxx:1930
TFormula_v5.cxx:1931
TFormula_v5.cxx:1932
TFormula_v5.cxx:1933
TFormula_v5.cxx:1934
TFormula_v5.cxx:1935
TFormula_v5.cxx:1936
TFormula_v5.cxx:1937
TFormula_v5.cxx:1938
TFormula_v5.cxx:1939
TFormula_v5.cxx:1940
TFormula_v5.cxx:1941
TFormula_v5.cxx:1942
TFormula_v5.cxx:1943
TFormula_v5.cxx:1944
TFormula_v5.cxx:1945
TFormula_v5.cxx:1946
TFormula_v5.cxx:1947
TFormula_v5.cxx:1948
TFormula_v5.cxx:1949
TFormula_v5.cxx:1950
TFormula_v5.cxx:1951
TFormula_v5.cxx:1952
TFormula_v5.cxx:1953
TFormula_v5.cxx:1954
TFormula_v5.cxx:1955
TFormula_v5.cxx:1956
TFormula_v5.cxx:1957
TFormula_v5.cxx:1958
TFormula_v5.cxx:1959
TFormula_v5.cxx:1960
TFormula_v5.cxx:1961
TFormula_v5.cxx:1962
TFormula_v5.cxx:1963
TFormula_v5.cxx:1964
TFormula_v5.cxx:1965
TFormula_v5.cxx:1966
TFormula_v5.cxx:1967
TFormula_v5.cxx:1968
TFormula_v5.cxx:1969
TFormula_v5.cxx:1970
TFormula_v5.cxx:1971
TFormula_v5.cxx:1972
TFormula_v5.cxx:1973
TFormula_v5.cxx:1974
TFormula_v5.cxx:1975
TFormula_v5.cxx:1976
TFormula_v5.cxx:1977
TFormula_v5.cxx:1978
TFormula_v5.cxx:1979
TFormula_v5.cxx:1980
TFormula_v5.cxx:1981
TFormula_v5.cxx:1982
TFormula_v5.cxx:1983
TFormula_v5.cxx:1984
TFormula_v5.cxx:1985
TFormula_v5.cxx:1986
TFormula_v5.cxx:1987
TFormula_v5.cxx:1988
TFormula_v5.cxx:1989
TFormula_v5.cxx:1990
TFormula_v5.cxx:1991
TFormula_v5.cxx:1992
TFormula_v5.cxx:1993
TFormula_v5.cxx:1994
TFormula_v5.cxx:1995
TFormula_v5.cxx:1996
TFormula_v5.cxx:1997
TFormula_v5.cxx:1998
TFormula_v5.cxx:1999
TFormula_v5.cxx:2000
TFormula_v5.cxx:2001
TFormula_v5.cxx:2002
TFormula_v5.cxx:2003
TFormula_v5.cxx:2004
TFormula_v5.cxx:2005
TFormula_v5.cxx:2006
TFormula_v5.cxx:2007
TFormula_v5.cxx:2008
TFormula_v5.cxx:2009
TFormula_v5.cxx:2010
TFormula_v5.cxx:2011
TFormula_v5.cxx:2012
TFormula_v5.cxx:2013
TFormula_v5.cxx:2014
TFormula_v5.cxx:2015
TFormula_v5.cxx:2016
TFormula_v5.cxx:2017
TFormula_v5.cxx:2018
TFormula_v5.cxx:2019
TFormula_v5.cxx:2020
TFormula_v5.cxx:2021
TFormula_v5.cxx:2022
TFormula_v5.cxx:2023
TFormula_v5.cxx:2024
TFormula_v5.cxx:2025
TFormula_v5.cxx:2026
TFormula_v5.cxx:2027
TFormula_v5.cxx:2028
TFormula_v5.cxx:2029
TFormula_v5.cxx:2030
TFormula_v5.cxx:2031
TFormula_v5.cxx:2032
TFormula_v5.cxx:2033
TFormula_v5.cxx:2034
TFormula_v5.cxx:2035
TFormula_v5.cxx:2036
TFormula_v5.cxx:2037
TFormula_v5.cxx:2038
TFormula_v5.cxx:2039
TFormula_v5.cxx:2040
TFormula_v5.cxx:2041
TFormula_v5.cxx:2042
TFormula_v5.cxx:2043
TFormula_v5.cxx:2044
TFormula_v5.cxx:2045
TFormula_v5.cxx:2046
TFormula_v5.cxx:2047
TFormula_v5.cxx:2048
TFormula_v5.cxx:2049
TFormula_v5.cxx:2050
TFormula_v5.cxx:2051
TFormula_v5.cxx:2052
TFormula_v5.cxx:2053
TFormula_v5.cxx:2054
TFormula_v5.cxx:2055
TFormula_v5.cxx:2056
TFormula_v5.cxx:2057
TFormula_v5.cxx:2058
TFormula_v5.cxx:2059
TFormula_v5.cxx:2060
TFormula_v5.cxx:2061
TFormula_v5.cxx:2062
TFormula_v5.cxx:2063
TFormula_v5.cxx:2064
TFormula_v5.cxx:2065
TFormula_v5.cxx:2066
TFormula_v5.cxx:2067
TFormula_v5.cxx:2068
TFormula_v5.cxx:2069
TFormula_v5.cxx:2070
TFormula_v5.cxx:2071
TFormula_v5.cxx:2072
TFormula_v5.cxx:2073
TFormula_v5.cxx:2074
TFormula_v5.cxx:2075
TFormula_v5.cxx:2076
TFormula_v5.cxx:2077
TFormula_v5.cxx:2078
TFormula_v5.cxx:2079
TFormula_v5.cxx:2080
TFormula_v5.cxx:2081
TFormula_v5.cxx:2082
TFormula_v5.cxx:2083
TFormula_v5.cxx:2084
TFormula_v5.cxx:2085
TFormula_v5.cxx:2086
TFormula_v5.cxx:2087
TFormula_v5.cxx:2088
TFormula_v5.cxx:2089
TFormula_v5.cxx:2090
TFormula_v5.cxx:2091
TFormula_v5.cxx:2092
TFormula_v5.cxx:2093
TFormula_v5.cxx:2094
TFormula_v5.cxx:2095
TFormula_v5.cxx:2096
TFormula_v5.cxx:2097
TFormula_v5.cxx:2098
TFormula_v5.cxx:2099
TFormula_v5.cxx:2100
TFormula_v5.cxx:2101
TFormula_v5.cxx:2102
TFormula_v5.cxx:2103
TFormula_v5.cxx:2104
TFormula_v5.cxx:2105
TFormula_v5.cxx:2106
TFormula_v5.cxx:2107
TFormula_v5.cxx:2108
TFormula_v5.cxx:2109
TFormula_v5.cxx:2110
TFormula_v5.cxx:2111
TFormula_v5.cxx:2112
TFormula_v5.cxx:2113
TFormula_v5.cxx:2114
TFormula_v5.cxx:2115
TFormula_v5.cxx:2116
TFormula_v5.cxx:2117
TFormula_v5.cxx:2118
TFormula_v5.cxx:2119
TFormula_v5.cxx:2120
TFormula_v5.cxx:2121
TFormula_v5.cxx:2122
TFormula_v5.cxx:2123
TFormula_v5.cxx:2124
TFormula_v5.cxx:2125
TFormula_v5.cxx:2126
TFormula_v5.cxx:2127
TFormula_v5.cxx:2128
TFormula_v5.cxx:2129
TFormula_v5.cxx:2130
TFormula_v5.cxx:2131
TFormula_v5.cxx:2132
TFormula_v5.cxx:2133
TFormula_v5.cxx:2134
TFormula_v5.cxx:2135
TFormula_v5.cxx:2136
TFormula_v5.cxx:2137
TFormula_v5.cxx:2138
TFormula_v5.cxx:2139
TFormula_v5.cxx:2140
TFormula_v5.cxx:2141
TFormula_v5.cxx:2142
TFormula_v5.cxx:2143
TFormula_v5.cxx:2144
TFormula_v5.cxx:2145
TFormula_v5.cxx:2146
TFormula_v5.cxx:2147
TFormula_v5.cxx:2148
TFormula_v5.cxx:2149
TFormula_v5.cxx:2150
TFormula_v5.cxx:2151
TFormula_v5.cxx:2152
TFormula_v5.cxx:2153
TFormula_v5.cxx:2154
TFormula_v5.cxx:2155
TFormula_v5.cxx:2156
TFormula_v5.cxx:2157
TFormula_v5.cxx:2158
TFormula_v5.cxx:2159
TFormula_v5.cxx:2160
TFormula_v5.cxx:2161
TFormula_v5.cxx:2162
TFormula_v5.cxx:2163
TFormula_v5.cxx:2164
TFormula_v5.cxx:2165
TFormula_v5.cxx:2166
TFormula_v5.cxx:2167
TFormula_v5.cxx:2168
TFormula_v5.cxx:2169
TFormula_v5.cxx:2170
TFormula_v5.cxx:2171
TFormula_v5.cxx:2172
TFormula_v5.cxx:2173
TFormula_v5.cxx:2174
TFormula_v5.cxx:2175
TFormula_v5.cxx:2176
TFormula_v5.cxx:2177
TFormula_v5.cxx:2178
TFormula_v5.cxx:2179
TFormula_v5.cxx:2180
TFormula_v5.cxx:2181
TFormula_v5.cxx:2182
TFormula_v5.cxx:2183
TFormula_v5.cxx:2184
TFormula_v5.cxx:2185
TFormula_v5.cxx:2186
TFormula_v5.cxx:2187
TFormula_v5.cxx:2188
TFormula_v5.cxx:2189
TFormula_v5.cxx:2190
TFormula_v5.cxx:2191
TFormula_v5.cxx:2192
TFormula_v5.cxx:2193
TFormula_v5.cxx:2194
TFormula_v5.cxx:2195
TFormula_v5.cxx:2196
TFormula_v5.cxx:2197
TFormula_v5.cxx:2198
TFormula_v5.cxx:2199
TFormula_v5.cxx:2200
TFormula_v5.cxx:2201
TFormula_v5.cxx:2202
TFormula_v5.cxx:2203
TFormula_v5.cxx:2204
TFormula_v5.cxx:2205
TFormula_v5.cxx:2206
TFormula_v5.cxx:2207
TFormula_v5.cxx:2208
TFormula_v5.cxx:2209
TFormula_v5.cxx:2210
TFormula_v5.cxx:2211
TFormula_v5.cxx:2212
TFormula_v5.cxx:2213
TFormula_v5.cxx:2214
TFormula_v5.cxx:2215
TFormula_v5.cxx:2216
TFormula_v5.cxx:2217
TFormula_v5.cxx:2218
TFormula_v5.cxx:2219
TFormula_v5.cxx:2220
TFormula_v5.cxx:2221
TFormula_v5.cxx:2222
TFormula_v5.cxx:2223
TFormula_v5.cxx:2224
TFormula_v5.cxx:2225
TFormula_v5.cxx:2226
TFormula_v5.cxx:2227
TFormula_v5.cxx:2228
TFormula_v5.cxx:2229
TFormula_v5.cxx:2230
TFormula_v5.cxx:2231
TFormula_v5.cxx:2232
TFormula_v5.cxx:2233
TFormula_v5.cxx:2234
TFormula_v5.cxx:2235
TFormula_v5.cxx:2236
TFormula_v5.cxx:2237
TFormula_v5.cxx:2238
TFormula_v5.cxx:2239
TFormula_v5.cxx:2240
TFormula_v5.cxx:2241
TFormula_v5.cxx:2242
TFormula_v5.cxx:2243
TFormula_v5.cxx:2244
TFormula_v5.cxx:2245
TFormula_v5.cxx:2246
TFormula_v5.cxx:2247
TFormula_v5.cxx:2248
TFormula_v5.cxx:2249
TFormula_v5.cxx:2250
TFormula_v5.cxx:2251
TFormula_v5.cxx:2252
TFormula_v5.cxx:2253
TFormula_v5.cxx:2254
TFormula_v5.cxx:2255
TFormula_v5.cxx:2256
TFormula_v5.cxx:2257
TFormula_v5.cxx:2258
TFormula_v5.cxx:2259
TFormula_v5.cxx:2260
TFormula_v5.cxx:2261
TFormula_v5.cxx:2262
TFormula_v5.cxx:2263
TFormula_v5.cxx:2264
TFormula_v5.cxx:2265
TFormula_v5.cxx:2266
TFormula_v5.cxx:2267
TFormula_v5.cxx:2268
TFormula_v5.cxx:2269
TFormula_v5.cxx:2270
TFormula_v5.cxx:2271
TFormula_v5.cxx:2272
TFormula_v5.cxx:2273
TFormula_v5.cxx:2274
TFormula_v5.cxx:2275
TFormula_v5.cxx:2276
TFormula_v5.cxx:2277
TFormula_v5.cxx:2278
TFormula_v5.cxx:2279
TFormula_v5.cxx:2280
TFormula_v5.cxx:2281
TFormula_v5.cxx:2282
TFormula_v5.cxx:2283
TFormula_v5.cxx:2284
TFormula_v5.cxx:2285
TFormula_v5.cxx:2286
TFormula_v5.cxx:2287
TFormula_v5.cxx:2288
TFormula_v5.cxx:2289
TFormula_v5.cxx:2290
TFormula_v5.cxx:2291
TFormula_v5.cxx:2292
TFormula_v5.cxx:2293
TFormula_v5.cxx:2294
TFormula_v5.cxx:2295
TFormula_v5.cxx:2296
TFormula_v5.cxx:2297
TFormula_v5.cxx:2298
TFormula_v5.cxx:2299
TFormula_v5.cxx:2300
TFormula_v5.cxx:2301
TFormula_v5.cxx:2302
TFormula_v5.cxx:2303
TFormula_v5.cxx:2304
TFormula_v5.cxx:2305
TFormula_v5.cxx:2306
TFormula_v5.cxx:2307
TFormula_v5.cxx:2308
TFormula_v5.cxx:2309
TFormula_v5.cxx:2310
TFormula_v5.cxx:2311
TFormula_v5.cxx:2312
TFormula_v5.cxx:2313
TFormula_v5.cxx:2314
TFormula_v5.cxx:2315
TFormula_v5.cxx:2316
TFormula_v5.cxx:2317
TFormula_v5.cxx:2318
TFormula_v5.cxx:2319
TFormula_v5.cxx:2320
TFormula_v5.cxx:2321
TFormula_v5.cxx:2322
TFormula_v5.cxx:2323
TFormula_v5.cxx:2324
TFormula_v5.cxx:2325
TFormula_v5.cxx:2326
TFormula_v5.cxx:2327
TFormula_v5.cxx:2328
TFormula_v5.cxx:2329
TFormula_v5.cxx:2330
TFormula_v5.cxx:2331
TFormula_v5.cxx:2332
TFormula_v5.cxx:2333
TFormula_v5.cxx:2334
TFormula_v5.cxx:2335
TFormula_v5.cxx:2336
TFormula_v5.cxx:2337
TFormula_v5.cxx:2338
TFormula_v5.cxx:2339
TFormula_v5.cxx:2340
TFormula_v5.cxx:2341
TFormula_v5.cxx:2342
TFormula_v5.cxx:2343
TFormula_v5.cxx:2344
TFormula_v5.cxx:2345
TFormula_v5.cxx:2346
TFormula_v5.cxx:2347
TFormula_v5.cxx:2348
TFormula_v5.cxx:2349
TFormula_v5.cxx:2350
TFormula_v5.cxx:2351
TFormula_v5.cxx:2352
TFormula_v5.cxx:2353
TFormula_v5.cxx:2354
TFormula_v5.cxx:2355
TFormula_v5.cxx:2356
TFormula_v5.cxx:2357
TFormula_v5.cxx:2358
TFormula_v5.cxx:2359
TFormula_v5.cxx:2360
TFormula_v5.cxx:2361
TFormula_v5.cxx:2362
TFormula_v5.cxx:2363
TFormula_v5.cxx:2364
TFormula_v5.cxx:2365
TFormula_v5.cxx:2366
TFormula_v5.cxx:2367
TFormula_v5.cxx:2368
TFormula_v5.cxx:2369
TFormula_v5.cxx:2370
TFormula_v5.cxx:2371
TFormula_v5.cxx:2372
TFormula_v5.cxx:2373
TFormula_v5.cxx:2374
TFormula_v5.cxx:2375
TFormula_v5.cxx:2376
TFormula_v5.cxx:2377
TFormula_v5.cxx:2378
TFormula_v5.cxx:2379
TFormula_v5.cxx:2380
TFormula_v5.cxx:2381
TFormula_v5.cxx:2382
TFormula_v5.cxx:2383
TFormula_v5.cxx:2384
TFormula_v5.cxx:2385
TFormula_v5.cxx:2386
TFormula_v5.cxx:2387
TFormula_v5.cxx:2388
TFormula_v5.cxx:2389
TFormula_v5.cxx:2390
TFormula_v5.cxx:2391
TFormula_v5.cxx:2392
TFormula_v5.cxx:2393
TFormula_v5.cxx:2394
TFormula_v5.cxx:2395
TFormula_v5.cxx:2396
TFormula_v5.cxx:2397
TFormula_v5.cxx:2398
TFormula_v5.cxx:2399
TFormula_v5.cxx:2400
TFormula_v5.cxx:2401
TFormula_v5.cxx:2402
TFormula_v5.cxx:2403
TFormula_v5.cxx:2404
TFormula_v5.cxx:2405
TFormula_v5.cxx:2406
TFormula_v5.cxx:2407
TFormula_v5.cxx:2408
TFormula_v5.cxx:2409
TFormula_v5.cxx:2410
TFormula_v5.cxx:2411
TFormula_v5.cxx:2412
TFormula_v5.cxx:2413
TFormula_v5.cxx:2414
TFormula_v5.cxx:2415
TFormula_v5.cxx:2416
TFormula_v5.cxx:2417
TFormula_v5.cxx:2418
TFormula_v5.cxx:2419
TFormula_v5.cxx:2420
TFormula_v5.cxx:2421
TFormula_v5.cxx:2422
TFormula_v5.cxx:2423
TFormula_v5.cxx:2424
TFormula_v5.cxx:2425
TFormula_v5.cxx:2426
TFormula_v5.cxx:2427
TFormula_v5.cxx:2428
TFormula_v5.cxx:2429
TFormula_v5.cxx:2430
TFormula_v5.cxx:2431
TFormula_v5.cxx:2432
TFormula_v5.cxx:2433
TFormula_v5.cxx:2434
TFormula_v5.cxx:2435
TFormula_v5.cxx:2436
TFormula_v5.cxx:2437
TFormula_v5.cxx:2438
TFormula_v5.cxx:2439
TFormula_v5.cxx:2440
TFormula_v5.cxx:2441
TFormula_v5.cxx:2442
TFormula_v5.cxx:2443
TFormula_v5.cxx:2444
TFormula_v5.cxx:2445
TFormula_v5.cxx:2446
TFormula_v5.cxx:2447
TFormula_v5.cxx:2448
TFormula_v5.cxx:2449
TFormula_v5.cxx:2450
TFormula_v5.cxx:2451
TFormula_v5.cxx:2452
TFormula_v5.cxx:2453
TFormula_v5.cxx:2454
TFormula_v5.cxx:2455
TFormula_v5.cxx:2456
TFormula_v5.cxx:2457
TFormula_v5.cxx:2458
TFormula_v5.cxx:2459
TFormula_v5.cxx:2460
TFormula_v5.cxx:2461
TFormula_v5.cxx:2462
TFormula_v5.cxx:2463
TFormula_v5.cxx:2464
TFormula_v5.cxx:2465
TFormula_v5.cxx:2466
TFormula_v5.cxx:2467
TFormula_v5.cxx:2468
TFormula_v5.cxx:2469
TFormula_v5.cxx:2470
TFormula_v5.cxx:2471
TFormula_v5.cxx:2472
TFormula_v5.cxx:2473
TFormula_v5.cxx:2474
TFormula_v5.cxx:2475
TFormula_v5.cxx:2476
TFormula_v5.cxx:2477
TFormula_v5.cxx:2478
TFormula_v5.cxx:2479
TFormula_v5.cxx:2480
TFormula_v5.cxx:2481
TFormula_v5.cxx:2482
TFormula_v5.cxx:2483
TFormula_v5.cxx:2484
TFormula_v5.cxx:2485
TFormula_v5.cxx:2486
TFormula_v5.cxx:2487
TFormula_v5.cxx:2488
TFormula_v5.cxx:2489
TFormula_v5.cxx:2490
TFormula_v5.cxx:2491
TFormula_v5.cxx:2492
TFormula_v5.cxx:2493
TFormula_v5.cxx:2494
TFormula_v5.cxx:2495
TFormula_v5.cxx:2496
TFormula_v5.cxx:2497
TFormula_v5.cxx:2498
TFormula_v5.cxx:2499
TFormula_v5.cxx:2500
TFormula_v5.cxx:2501
TFormula_v5.cxx:2502
TFormula_v5.cxx:2503
TFormula_v5.cxx:2504
TFormula_v5.cxx:2505
TFormula_v5.cxx:2506
TFormula_v5.cxx:2507
TFormula_v5.cxx:2508
TFormula_v5.cxx:2509
TFormula_v5.cxx:2510
TFormula_v5.cxx:2511
TFormula_v5.cxx:2512
TFormula_v5.cxx:2513
TFormula_v5.cxx:2514
TFormula_v5.cxx:2515
TFormula_v5.cxx:2516
TFormula_v5.cxx:2517
TFormula_v5.cxx:2518
TFormula_v5.cxx:2519
TFormula_v5.cxx:2520
TFormula_v5.cxx:2521
TFormula_v5.cxx:2522
TFormula_v5.cxx:2523
TFormula_v5.cxx:2524
TFormula_v5.cxx:2525
TFormula_v5.cxx:2526
TFormula_v5.cxx:2527
TFormula_v5.cxx:2528
TFormula_v5.cxx:2529
TFormula_v5.cxx:2530
TFormula_v5.cxx:2531
TFormula_v5.cxx:2532
TFormula_v5.cxx:2533
TFormula_v5.cxx:2534
TFormula_v5.cxx:2535
TFormula_v5.cxx:2536
TFormula_v5.cxx:2537
TFormula_v5.cxx:2538
TFormula_v5.cxx:2539
TFormula_v5.cxx:2540
TFormula_v5.cxx:2541
TFormula_v5.cxx:2542
TFormula_v5.cxx:2543
TFormula_v5.cxx:2544
TFormula_v5.cxx:2545
TFormula_v5.cxx:2546
TFormula_v5.cxx:2547
TFormula_v5.cxx:2548
TFormula_v5.cxx:2549
TFormula_v5.cxx:2550
TFormula_v5.cxx:2551
TFormula_v5.cxx:2552
TFormula_v5.cxx:2553
TFormula_v5.cxx:2554
TFormula_v5.cxx:2555
TFormula_v5.cxx:2556
TFormula_v5.cxx:2557
TFormula_v5.cxx:2558
TFormula_v5.cxx:2559
TFormula_v5.cxx:2560
TFormula_v5.cxx:2561
TFormula_v5.cxx:2562
TFormula_v5.cxx:2563
TFormula_v5.cxx:2564
TFormula_v5.cxx:2565
TFormula_v5.cxx:2566
TFormula_v5.cxx:2567
TFormula_v5.cxx:2568
TFormula_v5.cxx:2569
TFormula_v5.cxx:2570
TFormula_v5.cxx:2571
TFormula_v5.cxx:2572
TFormula_v5.cxx:2573
TFormula_v5.cxx:2574
TFormula_v5.cxx:2575
TFormula_v5.cxx:2576
TFormula_v5.cxx:2577
TFormula_v5.cxx:2578
TFormula_v5.cxx:2579
TFormula_v5.cxx:2580
TFormula_v5.cxx:2581
TFormula_v5.cxx:2582
TFormula_v5.cxx:2583
TFormula_v5.cxx:2584
TFormula_v5.cxx:2585
TFormula_v5.cxx:2586
TFormula_v5.cxx:2587
TFormula_v5.cxx:2588
TFormula_v5.cxx:2589
TFormula_v5.cxx:2590
TFormula_v5.cxx:2591
TFormula_v5.cxx:2592
TFormula_v5.cxx:2593
TFormula_v5.cxx:2594
TFormula_v5.cxx:2595
TFormula_v5.cxx:2596
TFormula_v5.cxx:2597
TFormula_v5.cxx:2598
TFormula_v5.cxx:2599
TFormula_v5.cxx:2600
TFormula_v5.cxx:2601
TFormula_v5.cxx:2602
TFormula_v5.cxx:2603
TFormula_v5.cxx:2604
TFormula_v5.cxx:2605
TFormula_v5.cxx:2606
TFormula_v5.cxx:2607
TFormula_v5.cxx:2608
TFormula_v5.cxx:2609
TFormula_v5.cxx:2610
TFormula_v5.cxx:2611
TFormula_v5.cxx:2612
TFormula_v5.cxx:2613
TFormula_v5.cxx:2614
TFormula_v5.cxx:2615
TFormula_v5.cxx:2616
TFormula_v5.cxx:2617
TFormula_v5.cxx:2618
TFormula_v5.cxx:2619
TFormula_v5.cxx:2620
TFormula_v5.cxx:2621
TFormula_v5.cxx:2622
TFormula_v5.cxx:2623
TFormula_v5.cxx:2624
TFormula_v5.cxx:2625
TFormula_v5.cxx:2626
TFormula_v5.cxx:2627
TFormula_v5.cxx:2628
TFormula_v5.cxx:2629
TFormula_v5.cxx:2630
TFormula_v5.cxx:2631
TFormula_v5.cxx:2632
TFormula_v5.cxx:2633
TFormula_v5.cxx:2634
TFormula_v5.cxx:2635
TFormula_v5.cxx:2636
TFormula_v5.cxx:2637
TFormula_v5.cxx:2638
TFormula_v5.cxx:2639
TFormula_v5.cxx:2640
TFormula_v5.cxx:2641
TFormula_v5.cxx:2642
TFormula_v5.cxx:2643
TFormula_v5.cxx:2644
TFormula_v5.cxx:2645
TFormula_v5.cxx:2646
TFormula_v5.cxx:2647
TFormula_v5.cxx:2648
TFormula_v5.cxx:2649
TFormula_v5.cxx:2650
TFormula_v5.cxx:2651
TFormula_v5.cxx:2652
TFormula_v5.cxx:2653
TFormula_v5.cxx:2654
TFormula_v5.cxx:2655
TFormula_v5.cxx:2656
TFormula_v5.cxx:2657
TFormula_v5.cxx:2658
TFormula_v5.cxx:2659
TFormula_v5.cxx:2660
TFormula_v5.cxx:2661
TFormula_v5.cxx:2662
TFormula_v5.cxx:2663
TFormula_v5.cxx:2664
TFormula_v5.cxx:2665
TFormula_v5.cxx:2666
TFormula_v5.cxx:2667
TFormula_v5.cxx:2668
TFormula_v5.cxx:2669
TFormula_v5.cxx:2670
TFormula_v5.cxx:2671
TFormula_v5.cxx:2672
TFormula_v5.cxx:2673
TFormula_v5.cxx:2674
TFormula_v5.cxx:2675
TFormula_v5.cxx:2676
TFormula_v5.cxx:2677
TFormula_v5.cxx:2678
TFormula_v5.cxx:2679
TFormula_v5.cxx:2680
TFormula_v5.cxx:2681
TFormula_v5.cxx:2682
TFormula_v5.cxx:2683
TFormula_v5.cxx:2684
TFormula_v5.cxx:2685
TFormula_v5.cxx:2686
TFormula_v5.cxx:2687
TFormula_v5.cxx:2688
TFormula_v5.cxx:2689
TFormula_v5.cxx:2690
TFormula_v5.cxx:2691
TFormula_v5.cxx:2692
TFormula_v5.cxx:2693
TFormula_v5.cxx:2694
TFormula_v5.cxx:2695
TFormula_v5.cxx:2696
TFormula_v5.cxx:2697
TFormula_v5.cxx:2698
TFormula_v5.cxx:2699
TFormula_v5.cxx:2700
TFormula_v5.cxx:2701
TFormula_v5.cxx:2702
TFormula_v5.cxx:2703
TFormula_v5.cxx:2704
TFormula_v5.cxx:2705
TFormula_v5.cxx:2706
TFormula_v5.cxx:2707
TFormula_v5.cxx:2708
TFormula_v5.cxx:2709
TFormula_v5.cxx:2710
TFormula_v5.cxx:2711
TFormula_v5.cxx:2712
TFormula_v5.cxx:2713
TFormula_v5.cxx:2714
TFormula_v5.cxx:2715
TFormula_v5.cxx:2716
TFormula_v5.cxx:2717
TFormula_v5.cxx:2718
TFormula_v5.cxx:2719
TFormula_v5.cxx:2720
TFormula_v5.cxx:2721
TFormula_v5.cxx:2722
TFormula_v5.cxx:2723
TFormula_v5.cxx:2724
TFormula_v5.cxx:2725
TFormula_v5.cxx:2726
TFormula_v5.cxx:2727
TFormula_v5.cxx:2728
TFormula_v5.cxx:2729
TFormula_v5.cxx:2730
TFormula_v5.cxx:2731
TFormula_v5.cxx:2732
TFormula_v5.cxx:2733
TFormula_v5.cxx:2734
TFormula_v5.cxx:2735
TFormula_v5.cxx:2736
TFormula_v5.cxx:2737
TFormula_v5.cxx:2738
TFormula_v5.cxx:2739
TFormula_v5.cxx:2740
TFormula_v5.cxx:2741
TFormula_v5.cxx:2742
TFormula_v5.cxx:2743
TFormula_v5.cxx:2744
TFormula_v5.cxx:2745
TFormula_v5.cxx:2746
TFormula_v5.cxx:2747
TFormula_v5.cxx:2748
TFormula_v5.cxx:2749
TFormula_v5.cxx:2750
TFormula_v5.cxx:2751
TFormula_v5.cxx:2752
TFormula_v5.cxx:2753
TFormula_v5.cxx:2754
TFormula_v5.cxx:2755
TFormula_v5.cxx:2756
TFormula_v5.cxx:2757
TFormula_v5.cxx:2758
TFormula_v5.cxx:2759
TFormula_v5.cxx:2760
TFormula_v5.cxx:2761
TFormula_v5.cxx:2762
TFormula_v5.cxx:2763
TFormula_v5.cxx:2764
TFormula_v5.cxx:2765
TFormula_v5.cxx:2766
TFormula_v5.cxx:2767
TFormula_v5.cxx:2768
TFormula_v5.cxx:2769
TFormula_v5.cxx:2770
TFormula_v5.cxx:2771
TFormula_v5.cxx:2772
TFormula_v5.cxx:2773
TFormula_v5.cxx:2774
TFormula_v5.cxx:2775
TFormula_v5.cxx:2776
TFormula_v5.cxx:2777
TFormula_v5.cxx:2778
TFormula_v5.cxx:2779
TFormula_v5.cxx:2780
TFormula_v5.cxx:2781
TFormula_v5.cxx:2782
TFormula_v5.cxx:2783
TFormula_v5.cxx:2784
TFormula_v5.cxx:2785
TFormula_v5.cxx:2786
TFormula_v5.cxx:2787
TFormula_v5.cxx:2788
TFormula_v5.cxx:2789
TFormula_v5.cxx:2790
TFormula_v5.cxx:2791
TFormula_v5.cxx:2792
TFormula_v5.cxx:2793
TFormula_v5.cxx:2794
TFormula_v5.cxx:2795
TFormula_v5.cxx:2796
TFormula_v5.cxx:2797
TFormula_v5.cxx:2798
TFormula_v5.cxx:2799
TFormula_v5.cxx:2800
TFormula_v5.cxx:2801
TFormula_v5.cxx:2802
TFormula_v5.cxx:2803
TFormula_v5.cxx:2804
TFormula_v5.cxx:2805
TFormula_v5.cxx:2806
TFormula_v5.cxx:2807
TFormula_v5.cxx:2808
TFormula_v5.cxx:2809
TFormula_v5.cxx:2810
TFormula_v5.cxx:2811
TFormula_v5.cxx:2812
TFormula_v5.cxx:2813
TFormula_v5.cxx:2814
TFormula_v5.cxx:2815
TFormula_v5.cxx:2816
TFormula_v5.cxx:2817
TFormula_v5.cxx:2818
TFormula_v5.cxx:2819
TFormula_v5.cxx:2820
TFormula_v5.cxx:2821
TFormula_v5.cxx:2822
TFormula_v5.cxx:2823
TFormula_v5.cxx:2824
TFormula_v5.cxx:2825
TFormula_v5.cxx:2826
TFormula_v5.cxx:2827
TFormula_v5.cxx:2828
TFormula_v5.cxx:2829
TFormula_v5.cxx:2830
TFormula_v5.cxx:2831
TFormula_v5.cxx:2832
TFormula_v5.cxx:2833
TFormula_v5.cxx:2834
TFormula_v5.cxx:2835
TFormula_v5.cxx:2836
TFormula_v5.cxx:2837
TFormula_v5.cxx:2838
TFormula_v5.cxx:2839
TFormula_v5.cxx:2840
TFormula_v5.cxx:2841
TFormula_v5.cxx:2842
TFormula_v5.cxx:2843
TFormula_v5.cxx:2844
TFormula_v5.cxx:2845
TFormula_v5.cxx:2846
TFormula_v5.cxx:2847
TFormula_v5.cxx:2848
TFormula_v5.cxx:2849
TFormula_v5.cxx:2850
TFormula_v5.cxx:2851
TFormula_v5.cxx:2852
TFormula_v5.cxx:2853
TFormula_v5.cxx:2854
TFormula_v5.cxx:2855
TFormula_v5.cxx:2856
TFormula_v5.cxx:2857
TFormula_v5.cxx:2858
TFormula_v5.cxx:2859
TFormula_v5.cxx:2860
TFormula_v5.cxx:2861
TFormula_v5.cxx:2862
TFormula_v5.cxx:2863
TFormula_v5.cxx:2864
TFormula_v5.cxx:2865
TFormula_v5.cxx:2866
TFormula_v5.cxx:2867
TFormula_v5.cxx:2868
TFormula_v5.cxx:2869
TFormula_v5.cxx:2870
TFormula_v5.cxx:2871
TFormula_v5.cxx:2872
TFormula_v5.cxx:2873
TFormula_v5.cxx:2874
TFormula_v5.cxx:2875
TFormula_v5.cxx:2876
TFormula_v5.cxx:2877
TFormula_v5.cxx:2878
TFormula_v5.cxx:2879
TFormula_v5.cxx:2880
TFormula_v5.cxx:2881
TFormula_v5.cxx:2882
TFormula_v5.cxx:2883
TFormula_v5.cxx:2884
TFormula_v5.cxx:2885
TFormula_v5.cxx:2886
TFormula_v5.cxx:2887
TFormula_v5.cxx:2888
TFormula_v5.cxx:2889
TFormula_v5.cxx:2890
TFormula_v5.cxx:2891
TFormula_v5.cxx:2892
TFormula_v5.cxx:2893
TFormula_v5.cxx:2894
TFormula_v5.cxx:2895
TFormula_v5.cxx:2896
TFormula_v5.cxx:2897
TFormula_v5.cxx:2898
TFormula_v5.cxx:2899
TFormula_v5.cxx:2900
TFormula_v5.cxx:2901
TFormula_v5.cxx:2902
TFormula_v5.cxx:2903
TFormula_v5.cxx:2904
TFormula_v5.cxx:2905
TFormula_v5.cxx:2906
TFormula_v5.cxx:2907
TFormula_v5.cxx:2908
TFormula_v5.cxx:2909
TFormula_v5.cxx:2910
TFormula_v5.cxx:2911
TFormula_v5.cxx:2912
TFormula_v5.cxx:2913
TFormula_v5.cxx:2914
TFormula_v5.cxx:2915
TFormula_v5.cxx:2916
TFormula_v5.cxx:2917
TFormula_v5.cxx:2918
TFormula_v5.cxx:2919
TFormula_v5.cxx:2920
TFormula_v5.cxx:2921
TFormula_v5.cxx:2922
TFormula_v5.cxx:2923
TFormula_v5.cxx:2924
TFormula_v5.cxx:2925
TFormula_v5.cxx:2926
TFormula_v5.cxx:2927
TFormula_v5.cxx:2928
TFormula_v5.cxx:2929
TFormula_v5.cxx:2930
TFormula_v5.cxx:2931
TFormula_v5.cxx:2932
TFormula_v5.cxx:2933
TFormula_v5.cxx:2934
TFormula_v5.cxx:2935
TFormula_v5.cxx:2936
TFormula_v5.cxx:2937
TFormula_v5.cxx:2938
TFormula_v5.cxx:2939
TFormula_v5.cxx:2940
TFormula_v5.cxx:2941
TFormula_v5.cxx:2942
TFormula_v5.cxx:2943
TFormula_v5.cxx:2944
TFormula_v5.cxx:2945
TFormula_v5.cxx:2946
TFormula_v5.cxx:2947
TFormula_v5.cxx:2948
TFormula_v5.cxx:2949
TFormula_v5.cxx:2950
TFormula_v5.cxx:2951
TFormula_v5.cxx:2952
TFormula_v5.cxx:2953
TFormula_v5.cxx:2954
TFormula_v5.cxx:2955
TFormula_v5.cxx:2956
TFormula_v5.cxx:2957
TFormula_v5.cxx:2958
TFormula_v5.cxx:2959
TFormula_v5.cxx:2960
TFormula_v5.cxx:2961
TFormula_v5.cxx:2962
TFormula_v5.cxx:2963
TFormula_v5.cxx:2964
TFormula_v5.cxx:2965
TFormula_v5.cxx:2966
TFormula_v5.cxx:2967
TFormula_v5.cxx:2968
TFormula_v5.cxx:2969
TFormula_v5.cxx:2970
TFormula_v5.cxx:2971
TFormula_v5.cxx:2972
TFormula_v5.cxx:2973
TFormula_v5.cxx:2974
TFormula_v5.cxx:2975
TFormula_v5.cxx:2976
TFormula_v5.cxx:2977
TFormula_v5.cxx:2978
TFormula_v5.cxx:2979
TFormula_v5.cxx:2980
TFormula_v5.cxx:2981
TFormula_v5.cxx:2982
TFormula_v5.cxx:2983
TFormula_v5.cxx:2984
TFormula_v5.cxx:2985
TFormula_v5.cxx:2986
TFormula_v5.cxx:2987
TFormula_v5.cxx:2988
TFormula_v5.cxx:2989
TFormula_v5.cxx:2990
TFormula_v5.cxx:2991
TFormula_v5.cxx:2992
TFormula_v5.cxx:2993
TFormula_v5.cxx:2994
TFormula_v5.cxx:2995
TFormula_v5.cxx:2996
TFormula_v5.cxx:2997
TFormula_v5.cxx:2998
TFormula_v5.cxx:2999
TFormula_v5.cxx:3000
TFormula_v5.cxx:3001
TFormula_v5.cxx:3002
TFormula_v5.cxx:3003
TFormula_v5.cxx:3004
TFormula_v5.cxx:3005
TFormula_v5.cxx:3006
TFormula_v5.cxx:3007
TFormula_v5.cxx:3008
TFormula_v5.cxx:3009
TFormula_v5.cxx:3010
TFormula_v5.cxx:3011
TFormula_v5.cxx:3012
TFormula_v5.cxx:3013
TFormula_v5.cxx:3014
TFormula_v5.cxx:3015
TFormula_v5.cxx:3016
TFormula_v5.cxx:3017
TFormula_v5.cxx:3018
TFormula_v5.cxx:3019
TFormula_v5.cxx:3020
TFormula_v5.cxx:3021
TFormula_v5.cxx:3022
TFormula_v5.cxx:3023
TFormula_v5.cxx:3024
TFormula_v5.cxx:3025
TFormula_v5.cxx:3026
TFormula_v5.cxx:3027
TFormula_v5.cxx:3028
TFormula_v5.cxx:3029
TFormula_v5.cxx:3030
TFormula_v5.cxx:3031
TFormula_v5.cxx:3032
TFormula_v5.cxx:3033
TFormula_v5.cxx:3034
TFormula_v5.cxx:3035
TFormula_v5.cxx:3036
TFormula_v5.cxx:3037
TFormula_v5.cxx:3038
TFormula_v5.cxx:3039
TFormula_v5.cxx:3040
TFormula_v5.cxx:3041
TFormula_v5.cxx:3042
TFormula_v5.cxx:3043
TFormula_v5.cxx:3044
TFormula_v5.cxx:3045
TFormula_v5.cxx:3046
TFormula_v5.cxx:3047
TFormula_v5.cxx:3048
TFormula_v5.cxx:3049
TFormula_v5.cxx:3050
TFormula_v5.cxx:3051
TFormula_v5.cxx:3052
TFormula_v5.cxx:3053
TFormula_v5.cxx:3054
TFormula_v5.cxx:3055
TFormula_v5.cxx:3056
TFormula_v5.cxx:3057
TFormula_v5.cxx:3058
TFormula_v5.cxx:3059
TFormula_v5.cxx:3060
TFormula_v5.cxx:3061
TFormula_v5.cxx:3062
TFormula_v5.cxx:3063
TFormula_v5.cxx:3064
TFormula_v5.cxx:3065
TFormula_v5.cxx:3066
TFormula_v5.cxx:3067
TFormula_v5.cxx:3068
TFormula_v5.cxx:3069
TFormula_v5.cxx:3070
TFormula_v5.cxx:3071
TFormula_v5.cxx:3072
TFormula_v5.cxx:3073
TFormula_v5.cxx:3074
TFormula_v5.cxx:3075
TFormula_v5.cxx:3076
TFormula_v5.cxx:3077
TFormula_v5.cxx:3078
TFormula_v5.cxx:3079
TFormula_v5.cxx:3080
TFormula_v5.cxx:3081
TFormula_v5.cxx:3082
TFormula_v5.cxx:3083
TFormula_v5.cxx:3084
TFormula_v5.cxx:3085
TFormula_v5.cxx:3086
TFormula_v5.cxx:3087
TFormula_v5.cxx:3088
TFormula_v5.cxx:3089
TFormula_v5.cxx:3090
TFormula_v5.cxx:3091
TFormula_v5.cxx:3092
TFormula_v5.cxx:3093
TFormula_v5.cxx:3094
TFormula_v5.cxx:3095
TFormula_v5.cxx:3096
TFormula_v5.cxx:3097
TFormula_v5.cxx:3098
TFormula_v5.cxx:3099
TFormula_v5.cxx:3100
TFormula_v5.cxx:3101
TFormula_v5.cxx:3102
TFormula_v5.cxx:3103
TFormula_v5.cxx:3104
TFormula_v5.cxx:3105
TFormula_v5.cxx:3106
TFormula_v5.cxx:3107
TFormula_v5.cxx:3108
TFormula_v5.cxx:3109
TFormula_v5.cxx:3110
TFormula_v5.cxx:3111
TFormula_v5.cxx:3112
TFormula_v5.cxx:3113
TFormula_v5.cxx:3114
TFormula_v5.cxx:3115
TFormula_v5.cxx:3116
TFormula_v5.cxx:3117
TFormula_v5.cxx:3118
TFormula_v5.cxx:3119
TFormula_v5.cxx:3120
TFormula_v5.cxx:3121
TFormula_v5.cxx:3122
TFormula_v5.cxx:3123
TFormula_v5.cxx:3124
TFormula_v5.cxx:3125
TFormula_v5.cxx:3126
TFormula_v5.cxx:3127
TFormula_v5.cxx:3128
TFormula_v5.cxx:3129
TFormula_v5.cxx:3130
TFormula_v5.cxx:3131
TFormula_v5.cxx:3132
TFormula_v5.cxx:3133
TFormula_v5.cxx:3134
TFormula_v5.cxx:3135
TFormula_v5.cxx:3136
TFormula_v5.cxx:3137
TFormula_v5.cxx:3138
TFormula_v5.cxx:3139
TFormula_v5.cxx:3140
TFormula_v5.cxx:3141
TFormula_v5.cxx:3142
TFormula_v5.cxx:3143
TFormula_v5.cxx:3144
TFormula_v5.cxx:3145
TFormula_v5.cxx:3146
TFormula_v5.cxx:3147
TFormula_v5.cxx:3148
TFormula_v5.cxx:3149
TFormula_v5.cxx:3150
TFormula_v5.cxx:3151
TFormula_v5.cxx:3152
TFormula_v5.cxx:3153
TFormula_v5.cxx:3154
TFormula_v5.cxx:3155
TFormula_v5.cxx:3156
TFormula_v5.cxx:3157
TFormula_v5.cxx:3158
TFormula_v5.cxx:3159
TFormula_v5.cxx:3160
TFormula_v5.cxx:3161
TFormula_v5.cxx:3162
TFormula_v5.cxx:3163
TFormula_v5.cxx:3164
TFormula_v5.cxx:3165
TFormula_v5.cxx:3166
TFormula_v5.cxx:3167
TFormula_v5.cxx:3168
TFormula_v5.cxx:3169
TFormula_v5.cxx:3170
TFormula_v5.cxx:3171
TFormula_v5.cxx:3172
TFormula_v5.cxx:3173
TFormula_v5.cxx:3174
TFormula_v5.cxx:3175
TFormula_v5.cxx:3176
TFormula_v5.cxx:3177
TFormula_v5.cxx:3178
TFormula_v5.cxx:3179
TFormula_v5.cxx:3180
TFormula_v5.cxx:3181
TFormula_v5.cxx:3182
TFormula_v5.cxx:3183
TFormula_v5.cxx:3184
TFormula_v5.cxx:3185
TFormula_v5.cxx:3186
TFormula_v5.cxx:3187
TFormula_v5.cxx:3188
TFormula_v5.cxx:3189
TFormula_v5.cxx:3190
TFormula_v5.cxx:3191
TFormula_v5.cxx:3192
TFormula_v5.cxx:3193
TFormula_v5.cxx:3194
TFormula_v5.cxx:3195
TFormula_v5.cxx:3196
TFormula_v5.cxx:3197
TFormula_v5.cxx:3198
TFormula_v5.cxx:3199
TFormula_v5.cxx:3200
TFormula_v5.cxx:3201
TFormula_v5.cxx:3202
TFormula_v5.cxx:3203
TFormula_v5.cxx:3204
TFormula_v5.cxx:3205
TFormula_v5.cxx:3206
TFormula_v5.cxx:3207
TFormula_v5.cxx:3208
TFormula_v5.cxx:3209
TFormula_v5.cxx:3210
TFormula_v5.cxx:3211
TFormula_v5.cxx:3212
TFormula_v5.cxx:3213
TFormula_v5.cxx:3214
TFormula_v5.cxx:3215
TFormula_v5.cxx:3216
TFormula_v5.cxx:3217
TFormula_v5.cxx:3218
TFormula_v5.cxx:3219
TFormula_v5.cxx:3220
TFormula_v5.cxx:3221
TFormula_v5.cxx:3222
TFormula_v5.cxx:3223
TFormula_v5.cxx:3224
TFormula_v5.cxx:3225
TFormula_v5.cxx:3226
TFormula_v5.cxx:3227
TFormula_v5.cxx:3228
TFormula_v5.cxx:3229
TFormula_v5.cxx:3230
TFormula_v5.cxx:3231
TFormula_v5.cxx:3232
TFormula_v5.cxx:3233
TFormula_v5.cxx:3234
TFormula_v5.cxx:3235
TFormula_v5.cxx:3236
TFormula_v5.cxx:3237
TFormula_v5.cxx:3238
TFormula_v5.cxx:3239
TFormula_v5.cxx:3240
TFormula_v5.cxx:3241
TFormula_v5.cxx:3242
TFormula_v5.cxx:3243
TFormula_v5.cxx:3244
TFormula_v5.cxx:3245
TFormula_v5.cxx:3246
TFormula_v5.cxx:3247
TFormula_v5.cxx:3248
TFormula_v5.cxx:3249
TFormula_v5.cxx:3250
TFormula_v5.cxx:3251
TFormula_v5.cxx:3252
TFormula_v5.cxx:3253
TFormula_v5.cxx:3254
TFormula_v5.cxx:3255
TFormula_v5.cxx:3256
TFormula_v5.cxx:3257
TFormula_v5.cxx:3258
TFormula_v5.cxx:3259
TFormula_v5.cxx:3260
TFormula_v5.cxx:3261
TFormula_v5.cxx:3262
TFormula_v5.cxx:3263
TFormula_v5.cxx:3264
TFormula_v5.cxx:3265
TFormula_v5.cxx:3266
TFormula_v5.cxx:3267
TFormula_v5.cxx:3268
TFormula_v5.cxx:3269
TFormula_v5.cxx:3270
TFormula_v5.cxx:3271
TFormula_v5.cxx:3272
TFormula_v5.cxx:3273
TFormula_v5.cxx:3274
TFormula_v5.cxx:3275
TFormula_v5.cxx:3276
TFormula_v5.cxx:3277
TFormula_v5.cxx:3278
TFormula_v5.cxx:3279
TFormula_v5.cxx:3280
TFormula_v5.cxx:3281
TFormula_v5.cxx:3282
TFormula_v5.cxx:3283
TFormula_v5.cxx:3284
TFormula_v5.cxx:3285
TFormula_v5.cxx:3286
TFormula_v5.cxx:3287
TFormula_v5.cxx:3288
TFormula_v5.cxx:3289
TFormula_v5.cxx:3290
TFormula_v5.cxx:3291
TFormula_v5.cxx:3292
TFormula_v5.cxx:3293
TFormula_v5.cxx:3294
TFormula_v5.cxx:3295
TFormula_v5.cxx:3296
TFormula_v5.cxx:3297
TFormula_v5.cxx:3298
TFormula_v5.cxx:3299
TFormula_v5.cxx:3300
TFormula_v5.cxx:3301
TFormula_v5.cxx:3302
TFormula_v5.cxx:3303
TFormula_v5.cxx:3304
TFormula_v5.cxx:3305
TFormula_v5.cxx:3306
TFormula_v5.cxx:3307
TFormula_v5.cxx:3308
TFormula_v5.cxx:3309
TFormula_v5.cxx:3310
TFormula_v5.cxx:3311
TFormula_v5.cxx:3312
TFormula_v5.cxx:3313
TFormula_v5.cxx:3314
TFormula_v5.cxx:3315
TFormula_v5.cxx:3316
TFormula_v5.cxx:3317
TFormula_v5.cxx:3318
TFormula_v5.cxx:3319
TFormula_v5.cxx:3320
TFormula_v5.cxx:3321
TFormula_v5.cxx:3322
TFormula_v5.cxx:3323
TFormula_v5.cxx:3324
TFormula_v5.cxx:3325
TFormula_v5.cxx:3326
TFormula_v5.cxx:3327
TFormula_v5.cxx:3328
TFormula_v5.cxx:3329
TFormula_v5.cxx:3330
TFormula_v5.cxx:3331
TFormula_v5.cxx:3332
TFormula_v5.cxx:3333
TFormula_v5.cxx:3334
TFormula_v5.cxx:3335
TFormula_v5.cxx:3336
TFormula_v5.cxx:3337
TFormula_v5.cxx:3338
TFormula_v5.cxx:3339
TFormula_v5.cxx:3340
TFormula_v5.cxx:3341
TFormula_v5.cxx:3342
TFormula_v5.cxx:3343
TFormula_v5.cxx:3344
TFormula_v5.cxx:3345
TFormula_v5.cxx:3346
TFormula_v5.cxx:3347
TFormula_v5.cxx:3348
TFormula_v5.cxx:3349
TFormula_v5.cxx:3350
TFormula_v5.cxx:3351
TFormula_v5.cxx:3352
TFormula_v5.cxx:3353
TFormula_v5.cxx:3354
TFormula_v5.cxx:3355
TFormula_v5.cxx:3356
TFormula_v5.cxx:3357
TFormula_v5.cxx:3358
TFormula_v5.cxx:3359
TFormula_v5.cxx:3360
TFormula_v5.cxx:3361
TFormula_v5.cxx:3362
TFormula_v5.cxx:3363
TFormula_v5.cxx:3364
TFormula_v5.cxx:3365
TFormula_v5.cxx:3366
TFormula_v5.cxx:3367
TFormula_v5.cxx:3368
TFormula_v5.cxx:3369
TFormula_v5.cxx:3370
TFormula_v5.cxx:3371
TFormula_v5.cxx:3372
TFormula_v5.cxx:3373
TFormula_v5.cxx:3374
TFormula_v5.cxx:3375
TFormula_v5.cxx:3376
TFormula_v5.cxx:3377
TFormula_v5.cxx:3378
TFormula_v5.cxx:3379
TFormula_v5.cxx:3380
TFormula_v5.cxx:3381
TFormula_v5.cxx:3382
TFormula_v5.cxx:3383
TFormula_v5.cxx:3384
TFormula_v5.cxx:3385
TFormula_v5.cxx:3386
TFormula_v5.cxx:3387
TFormula_v5.cxx:3388
TFormula_v5.cxx:3389
TFormula_v5.cxx:3390
TFormula_v5.cxx:3391
TFormula_v5.cxx:3392
TFormula_v5.cxx:3393
TFormula_v5.cxx:3394
TFormula_v5.cxx:3395
TFormula_v5.cxx:3396
TFormula_v5.cxx:3397
TFormula_v5.cxx:3398
TFormula_v5.cxx:3399
TFormula_v5.cxx:3400
TFormula_v5.cxx:3401
TFormula_v5.cxx:3402
TFormula_v5.cxx:3403
TFormula_v5.cxx:3404
TFormula_v5.cxx:3405
TFormula_v5.cxx:3406
TFormula_v5.cxx:3407
TFormula_v5.cxx:3408
TFormula_v5.cxx:3409
TFormula_v5.cxx:3410
TFormula_v5.cxx:3411
TFormula_v5.cxx:3412
TFormula_v5.cxx:3413
TFormula_v5.cxx:3414
TFormula_v5.cxx:3415
TFormula_v5.cxx:3416
TFormula_v5.cxx:3417
TFormula_v5.cxx:3418
TFormula_v5.cxx:3419
TFormula_v5.cxx:3420
TFormula_v5.cxx:3421
TFormula_v5.cxx:3422
TFormula_v5.cxx:3423
TFormula_v5.cxx:3424
TFormula_v5.cxx:3425
TFormula_v5.cxx:3426
TFormula_v5.cxx:3427
TFormula_v5.cxx:3428
TFormula_v5.cxx:3429
TFormula_v5.cxx:3430
TFormula_v5.cxx:3431
TFormula_v5.cxx:3432
TFormula_v5.cxx:3433
TFormula_v5.cxx:3434
TFormula_v5.cxx:3435
TFormula_v5.cxx:3436
TFormula_v5.cxx:3437
TFormula_v5.cxx:3438
TFormula_v5.cxx:3439
TFormula_v5.cxx:3440
TFormula_v5.cxx:3441
TFormula_v5.cxx:3442
TFormula_v5.cxx:3443
TFormula_v5.cxx:3444
TFormula_v5.cxx:3445
TFormula_v5.cxx:3446
TFormula_v5.cxx:3447
TFormula_v5.cxx:3448
TFormula_v5.cxx:3449
TFormula_v5.cxx:3450
TFormula_v5.cxx:3451
TFormula_v5.cxx:3452
TFormula_v5.cxx:3453
TFormula_v5.cxx:3454
TFormula_v5.cxx:3455
TFormula_v5.cxx:3456
TFormula_v5.cxx:3457
TFormula_v5.cxx:3458
TFormula_v5.cxx:3459
TFormula_v5.cxx:3460
TFormula_v5.cxx:3461
TFormula_v5.cxx:3462
TFormula_v5.cxx:3463
TFormula_v5.cxx:3464
TFormula_v5.cxx:3465
TFormula_v5.cxx:3466
TFormula_v5.cxx:3467
TFormula_v5.cxx:3468
TFormula_v5.cxx:3469
TFormula_v5.cxx:3470
TFormula_v5.cxx:3471
TFormula_v5.cxx:3472
TFormula_v5.cxx:3473
TFormula_v5.cxx:3474
TFormula_v5.cxx:3475
TFormula_v5.cxx:3476
TFormula_v5.cxx:3477
TFormula_v5.cxx:3478
TFormula_v5.cxx:3479
TFormula_v5.cxx:3480
TFormula_v5.cxx:3481
TFormula_v5.cxx:3482
TFormula_v5.cxx:3483
TFormula_v5.cxx:3484
TFormula_v5.cxx:3485
TFormula_v5.cxx:3486
TFormula_v5.cxx:3487
TFormula_v5.cxx:3488
TFormula_v5.cxx:3489
TFormula_v5.cxx:3490
TFormula_v5.cxx:3491
TFormula_v5.cxx:3492
TFormula_v5.cxx:3493
TFormula_v5.cxx:3494
TFormula_v5.cxx:3495
TFormula_v5.cxx:3496
TFormula_v5.cxx:3497
TFormula_v5.cxx:3498
TFormula_v5.cxx:3499
TFormula_v5.cxx:3500
TFormula_v5.cxx:3501
TFormula_v5.cxx:3502
TFormula_v5.cxx:3503
TFormula_v5.cxx:3504
TFormula_v5.cxx:3505
TFormula_v5.cxx:3506
TFormula_v5.cxx:3507
TFormula_v5.cxx:3508
TFormula_v5.cxx:3509
TFormula_v5.cxx:3510
TFormula_v5.cxx:3511
TFormula_v5.cxx:3512
TFormula_v5.cxx:3513
TFormula_v5.cxx:3514
TFormula_v5.cxx:3515
TFormula_v5.cxx:3516
TFormula_v5.cxx:3517
TFormula_v5.cxx:3518
TFormula_v5.cxx:3519
TFormula_v5.cxx:3520
TFormula_v5.cxx:3521
TFormula_v5.cxx:3522
TFormula_v5.cxx:3523
TFormula_v5.cxx:3524
TFormula_v5.cxx:3525
TFormula_v5.cxx:3526
TFormula_v5.cxx:3527
TFormula_v5.cxx:3528
TFormula_v5.cxx:3529
TFormula_v5.cxx:3530
TFormula_v5.cxx:3531
TFormula_v5.cxx:3532
TFormula_v5.cxx:3533
TFormula_v5.cxx:3534
TFormula_v5.cxx:3535
TFormula_v5.cxx:3536
TFormula_v5.cxx:3537
TFormula_v5.cxx:3538
TFormula_v5.cxx:3539
TFormula_v5.cxx:3540
TFormula_v5.cxx:3541
TFormula_v5.cxx:3542
TFormula_v5.cxx:3543
TFormula_v5.cxx:3544
TFormula_v5.cxx:3545
TFormula_v5.cxx:3546
TFormula_v5.cxx:3547
TFormula_v5.cxx:3548
TFormula_v5.cxx:3549
TFormula_v5.cxx:3550
TFormula_v5.cxx:3551
TFormula_v5.cxx:3552
TFormula_v5.cxx:3553
TFormula_v5.cxx:3554
TFormula_v5.cxx:3555
TFormula_v5.cxx:3556
TFormula_v5.cxx:3557
TFormula_v5.cxx:3558
TFormula_v5.cxx:3559
TFormula_v5.cxx:3560
TFormula_v5.cxx:3561
TFormula_v5.cxx:3562
TFormula_v5.cxx:3563
TFormula_v5.cxx:3564
TFormula_v5.cxx:3565
TFormula_v5.cxx:3566
TFormula_v5.cxx:3567
TFormula_v5.cxx:3568
TFormula_v5.cxx:3569
TFormula_v5.cxx:3570
TFormula_v5.cxx:3571
TFormula_v5.cxx:3572
TFormula_v5.cxx:3573
TFormula_v5.cxx:3574
TFormula_v5.cxx:3575
TFormula_v5.cxx:3576
TFormula_v5.cxx:3577
TFormula_v5.cxx:3578
TFormula_v5.cxx:3579
TFormula_v5.cxx:3580
TFormula_v5.cxx:3581
TFormula_v5.cxx:3582
TFormula_v5.cxx:3583
TFormula_v5.cxx:3584
TFormula_v5.cxx:3585
TFormula_v5.cxx:3586
TFormula_v5.cxx:3587
TFormula_v5.cxx:3588
TFormula_v5.cxx:3589
TFormula_v5.cxx:3590
TFormula_v5.cxx:3591
TFormula_v5.cxx:3592
TFormula_v5.cxx:3593
TFormula_v5.cxx:3594
TFormula_v5.cxx:3595
TFormula_v5.cxx:3596
TFormula_v5.cxx:3597
TFormula_v5.cxx:3598
TFormula_v5.cxx:3599
TFormula_v5.cxx:3600
TFormula_v5.cxx:3601
TFormula_v5.cxx:3602
TFormula_v5.cxx:3603
TFormula_v5.cxx:3604
TFormula_v5.cxx:3605
TFormula_v5.cxx:3606
TFormula_v5.cxx:3607
TFormula_v5.cxx:3608
TFormula_v5.cxx:3609
TFormula_v5.cxx:3610
TFormula_v5.cxx:3611
TFormula_v5.cxx:3612
TFormula_v5.cxx:3613
TFormula_v5.cxx:3614
TFormula_v5.cxx:3615
TFormula_v5.cxx:3616
TFormula_v5.cxx:3617
TFormula_v5.cxx:3618
TFormula_v5.cxx:3619
TFormula_v5.cxx:3620
TFormula_v5.cxx:3621
TFormula_v5.cxx:3622
TFormula_v5.cxx:3623
TFormula_v5.cxx:3624
TFormula_v5.cxx:3625
TFormula_v5.cxx:3626
TFormula_v5.cxx:3627
TFormula_v5.cxx:3628
TFormula_v5.cxx:3629
TFormula_v5.cxx:3630
TFormula_v5.cxx:3631
TFormula_v5.cxx:3632
TFormula_v5.cxx:3633
TFormula_v5.cxx:3634
TFormula_v5.cxx:3635
TFormula_v5.cxx:3636
TFormula_v5.cxx:3637
TFormula_v5.cxx:3638
TFormula_v5.cxx:3639
TFormula_v5.cxx:3640
TFormula_v5.cxx:3641
TFormula_v5.cxx:3642
TFormula_v5.cxx:3643
TFormula_v5.cxx:3644
TFormula_v5.cxx:3645
TFormula_v5.cxx:3646
TFormula_v5.cxx:3647
TFormula_v5.cxx:3648
TFormula_v5.cxx:3649
TFormula_v5.cxx:3650
TFormula_v5.cxx:3651
TFormula_v5.cxx:3652
TFormula_v5.cxx:3653
TFormula_v5.cxx:3654
TFormula_v5.cxx:3655
TFormula_v5.cxx:3656
TFormula_v5.cxx:3657
TFormula_v5.cxx:3658
TFormula_v5.cxx:3659
TFormula_v5.cxx:3660
TFormula_v5.cxx:3661
TFormula_v5.cxx:3662
TFormula_v5.cxx:3663
TFormula_v5.cxx:3664
TFormula_v5.cxx:3665
TFormula_v5.cxx:3666
TFormula_v5.cxx:3667
TFormula_v5.cxx:3668
TFormula_v5.cxx:3669
TFormula_v5.cxx:3670
TFormula_v5.cxx:3671
TFormula_v5.cxx:3672
TFormula_v5.cxx:3673
TFormula_v5.cxx:3674
TFormula_v5.cxx:3675
TFormula_v5.cxx:3676
TFormula_v5.cxx:3677
TFormula_v5.cxx:3678
TFormula_v5.cxx:3679
TFormula_v5.cxx:3680
TFormula_v5.cxx:3681
TFormula_v5.cxx:3682
TFormula_v5.cxx:3683
TFormula_v5.cxx:3684
TFormula_v5.cxx:3685
TFormula_v5.cxx:3686
TFormula_v5.cxx:3687
TFormula_v5.cxx:3688
TFormula_v5.cxx:3689
TFormula_v5.cxx:3690
TFormula_v5.cxx:3691
TFormula_v5.cxx:3692
TFormula_v5.cxx:3693
TFormula_v5.cxx:3694
TFormula_v5.cxx:3695
TFormula_v5.cxx:3696
TFormula_v5.cxx:3697
TFormula_v5.cxx:3698
TFormula_v5.cxx:3699
TFormula_v5.cxx:3700
TFormula_v5.cxx:3701
TFormula_v5.cxx:3702
TFormula_v5.cxx:3703
TFormula_v5.cxx:3704
TFormula_v5.cxx:3705
TFormula_v5.cxx:3706
TFormula_v5.cxx:3707
TFormula_v5.cxx:3708
TFormula_v5.cxx:3709
TFormula_v5.cxx:3710
TFormula_v5.cxx:3711
TFormula_v5.cxx:3712
TFormula_v5.cxx:3713
TFormula_v5.cxx:3714
TFormula_v5.cxx:3715
TFormula_v5.cxx:3716
TFormula_v5.cxx:3717
TFormula_v5.cxx:3718
TFormula_v5.cxx:3719
TFormula_v5.cxx:3720
TFormula_v5.cxx:3721
TFormula_v5.cxx:3722
TFormula_v5.cxx:3723
TFormula_v5.cxx:3724
TFormula_v5.cxx:3725
TFormula_v5.cxx:3726
TFormula_v5.cxx:3727
TFormula_v5.cxx:3728
TFormula_v5.cxx:3729
TFormula_v5.cxx:3730
TFormula_v5.cxx:3731
TFormula_v5.cxx:3732
TFormula_v5.cxx:3733
TFormula_v5.cxx:3734
TFormula_v5.cxx:3735
TFormula_v5.cxx:3736
TFormula_v5.cxx:3737
TFormula_v5.cxx:3738
TFormula_v5.cxx:3739
TFormula_v5.cxx:3740
TFormula_v5.cxx:3741
TFormula_v5.cxx:3742
TFormula_v5.cxx:3743
TFormula_v5.cxx:3744
TFormula_v5.cxx:3745
TFormula_v5.cxx:3746
TFormula_v5.cxx:3747
TFormula_v5.cxx:3748
TFormula_v5.cxx:3749
TFormula_v5.cxx:3750
TFormula_v5.cxx:3751
TFormula_v5.cxx:3752
TFormula_v5.cxx:3753
TFormula_v5.cxx:3754
TFormula_v5.cxx:3755
TFormula_v5.cxx:3756
TFormula_v5.cxx:3757
TFormula_v5.cxx:3758
TFormula_v5.cxx:3759
TFormula_v5.cxx:3760
TFormula_v5.cxx:3761
TFormula_v5.cxx:3762
TFormula_v5.cxx:3763
TFormula_v5.cxx:3764
TFormula_v5.cxx:3765
TFormula_v5.cxx:3766
TFormula_v5.cxx:3767
TFormula_v5.cxx:3768
TFormula_v5.cxx:3769
TFormula_v5.cxx:3770
TFormula_v5.cxx:3771
TFormula_v5.cxx:3772
TFormula_v5.cxx:3773
TFormula_v5.cxx:3774
TFormula_v5.cxx:3775
TFormula_v5.cxx:3776
TFormula_v5.cxx:3777
TFormula_v5.cxx:3778
TFormula_v5.cxx:3779
TFormula_v5.cxx:3780
TFormula_v5.cxx:3781
TFormula_v5.cxx:3782
TFormula_v5.cxx:3783
TFormula_v5.cxx:3784
TFormula_v5.cxx:3785
TFormula_v5.cxx:3786
TFormula_v5.cxx:3787
TFormula_v5.cxx:3788
TFormula_v5.cxx:3789
TFormula_v5.cxx:3790
TFormula_v5.cxx:3791
TFormula_v5.cxx:3792
TFormula_v5.cxx:3793
TFormula_v5.cxx:3794
TFormula_v5.cxx:3795
TFormula_v5.cxx:3796
TFormula_v5.cxx:3797
TFormula_v5.cxx:3798
TFormula_v5.cxx:3799
TFormula_v5.cxx:3800
TFormula_v5.cxx:3801
TFormula_v5.cxx:3802
TFormula_v5.cxx:3803
TFormula_v5.cxx:3804
TFormula_v5.cxx:3805
TFormula_v5.cxx:3806
TFormula_v5.cxx:3807
TFormula_v5.cxx:3808
TFormula_v5.cxx:3809
TFormula_v5.cxx:3810
TFormula_v5.cxx:3811
TFormula_v5.cxx:3812
TFormula_v5.cxx:3813
TFormula_v5.cxx:3814
TFormula_v5.cxx:3815
TFormula_v5.cxx:3816
TFormula_v5.cxx:3817
TFormula_v5.cxx:3818
TFormula_v5.cxx:3819
TFormula_v5.cxx:3820
TFormula_v5.cxx:3821
TFormula_v5.cxx:3822
TFormula_v5.cxx:3823
TFormula_v5.cxx:3824
TFormula_v5.cxx:3825
TFormula_v5.cxx:3826
TFormula_v5.cxx:3827
TFormula_v5.cxx:3828
TFormula_v5.cxx:3829
TFormula_v5.cxx:3830
TFormula_v5.cxx:3831
TFormula_v5.cxx:3832
TFormula_v5.cxx:3833
TFormula_v5.cxx:3834
TFormula_v5.cxx:3835
TFormula_v5.cxx:3836
TFormula_v5.cxx:3837
TFormula_v5.cxx:3838
TFormula_v5.cxx:3839
TFormula_v5.cxx:3840
TFormula_v5.cxx:3841
TFormula_v5.cxx:3842
TFormula_v5.cxx:3843
TFormula_v5.cxx:3844
TFormula_v5.cxx:3845
TFormula_v5.cxx:3846
TFormula_v5.cxx:3847
TFormula_v5.cxx:3848
TFormula_v5.cxx:3849
TFormula_v5.cxx:3850
TFormula_v5.cxx:3851
TFormula_v5.cxx:3852
TFormula_v5.cxx:3853
TFormula_v5.cxx:3854
TFormula_v5.cxx:3855
TFormula_v5.cxx:3856
TFormula_v5.cxx:3857
TFormula_v5.cxx:3858
TFormula_v5.cxx:3859
TFormula_v5.cxx:3860
TFormula_v5.cxx:3861
TFormula_v5.cxx:3862
TFormula_v5.cxx:3863
TFormula_v5.cxx:3864
TFormula_v5.cxx:3865
TFormula_v5.cxx:3866
TFormula_v5.cxx:3867
TFormula_v5.cxx:3868
TFormula_v5.cxx:3869
TFormula_v5.cxx:3870
TFormula_v5.cxx:3871
TFormula_v5.cxx:3872
TFormula_v5.cxx:3873
TFormula_v5.cxx:3874
TFormula_v5.cxx:3875
TFormula_v5.cxx:3876
TFormula_v5.cxx:3877
TFormula_v5.cxx:3878
TFormula_v5.cxx:3879
TFormula_v5.cxx:3880
TFormula_v5.cxx:3881
TFormula_v5.cxx:3882
TFormula_v5.cxx:3883
TFormula_v5.cxx:3884
TFormula_v5.cxx:3885
TFormula_v5.cxx:3886
TFormula_v5.cxx:3887
TFormula_v5.cxx:3888
TFormula_v5.cxx:3889
TFormula_v5.cxx:3890
TFormula_v5.cxx:3891
TFormula_v5.cxx:3892
TFormula_v5.cxx:3893
TFormula_v5.cxx:3894
TFormula_v5.cxx:3895
TFormula_v5.cxx:3896
TFormula_v5.cxx:3897
TFormula_v5.cxx:3898
TFormula_v5.cxx:3899
TFormula_v5.cxx:3900
TFormula_v5.cxx:3901
TFormula_v5.cxx:3902
TFormula_v5.cxx:3903
TFormula_v5.cxx:3904
TFormula_v5.cxx:3905
TFormula_v5.cxx:3906
TFormula_v5.cxx:3907
TFormula_v5.cxx:3908
TFormula_v5.cxx:3909
TFormula_v5.cxx:3910
TFormula_v5.cxx:3911
TFormula_v5.cxx:3912
TFormula_v5.cxx:3913
TFormula_v5.cxx:3914
TFormula_v5.cxx:3915
TFormula_v5.cxx:3916
TFormula_v5.cxx:3917
TFormula_v5.cxx:3918
TFormula_v5.cxx:3919
TFormula_v5.cxx:3920
TFormula_v5.cxx:3921
TFormula_v5.cxx:3922
TFormula_v5.cxx:3923
TFormula_v5.cxx:3924
TFormula_v5.cxx:3925
TFormula_v5.cxx:3926
TFormula_v5.cxx:3927
TFormula_v5.cxx:3928
TFormula_v5.cxx:3929
TFormula_v5.cxx:3930
TFormula_v5.cxx:3931
TFormula_v5.cxx:3932
TFormula_v5.cxx:3933
TFormula_v5.cxx:3934
TFormula_v5.cxx:3935
TFormula_v5.cxx:3936
TFormula_v5.cxx:3937
TFormula_v5.cxx:3938
TFormula_v5.cxx:3939
TFormula_v5.cxx:3940
TFormula_v5.cxx:3941
TFormula_v5.cxx:3942
TFormula_v5.cxx:3943
TFormula_v5.cxx:3944
TFormula_v5.cxx:3945
TFormula_v5.cxx:3946
TFormula_v5.cxx:3947
TFormula_v5.cxx:3948
TFormula_v5.cxx:3949
TFormula_v5.cxx:3950
TFormula_v5.cxx:3951
TFormula_v5.cxx:3952
TFormula_v5.cxx:3953
TFormula_v5.cxx:3954
TFormula_v5.cxx:3955
TFormula_v5.cxx:3956
TFormula_v5.cxx:3957
TFormula_v5.cxx:3958
TFormula_v5.cxx:3959
TFormula_v5.cxx:3960
TFormula_v5.cxx:3961
TFormula_v5.cxx:3962
TFormula_v5.cxx:3963
TFormula_v5.cxx:3964
TFormula_v5.cxx:3965
TFormula_v5.cxx:3966
TFormula_v5.cxx:3967
TFormula_v5.cxx:3968
TFormula_v5.cxx:3969
TFormula_v5.cxx:3970
TFormula_v5.cxx:3971
TFormula_v5.cxx:3972
TFormula_v5.cxx:3973
TFormula_v5.cxx:3974
TFormula_v5.cxx:3975
TFormula_v5.cxx:3976
TFormula_v5.cxx:3977
TFormula_v5.cxx:3978
TFormula_v5.cxx:3979
TFormula_v5.cxx:3980
TFormula_v5.cxx:3981
TFormula_v5.cxx:3982
TFormula_v5.cxx:3983
TFormula_v5.cxx:3984
TFormula_v5.cxx:3985
TFormula_v5.cxx:3986
TFormula_v5.cxx:3987
TFormula_v5.cxx:3988
TFormula_v5.cxx:3989
TFormula_v5.cxx:3990
TFormula_v5.cxx:3991
TFormula_v5.cxx:3992
TFormula_v5.cxx:3993
TFormula_v5.cxx:3994
TFormula_v5.cxx:3995
TFormula_v5.cxx:3996
TFormula_v5.cxx:3997
TFormula_v5.cxx:3998
TFormula_v5.cxx:3999
TFormula_v5.cxx:4000
TFormula_v5.cxx:4001
TFormula_v5.cxx:4002
TFormula_v5.cxx:4003
TFormula_v5.cxx:4004
TFormula_v5.cxx:4005
TFormula_v5.cxx:4006
TFormula_v5.cxx:4007
TFormula_v5.cxx:4008
TFormula_v5.cxx:4009
TFormula_v5.cxx:4010
TFormula_v5.cxx:4011
TFormula_v5.cxx:4012
TFormula_v5.cxx:4013
TFormula_v5.cxx:4014
TFormula_v5.cxx:4015
TFormula_v5.cxx:4016
TFormula_v5.cxx:4017
TFormula_v5.cxx:4018
TFormula_v5.cxx:4019
TFormula_v5.cxx:4020
TFormula_v5.cxx:4021
TFormula_v5.cxx:4022
TFormula_v5.cxx:4023
TFormula_v5.cxx:4024
TFormula_v5.cxx:4025
TFormula_v5.cxx:4026
TFormula_v5.cxx:4027
TFormula_v5.cxx:4028
TFormula_v5.cxx:4029
TFormula_v5.cxx:4030
TFormula_v5.cxx:4031
TFormula_v5.cxx:4032
TFormula_v5.cxx:4033
TFormula_v5.cxx:4034
TFormula_v5.cxx:4035
TFormula_v5.cxx:4036
TFormula_v5.cxx:4037
TFormula_v5.cxx:4038
TFormula_v5.cxx:4039
TFormula_v5.cxx:4040
TFormula_v5.cxx:4041
TFormula_v5.cxx:4042
TFormula_v5.cxx:4043
TFormula_v5.cxx:4044
TFormula_v5.cxx:4045
TFormula_v5.cxx:4046
TFormula_v5.cxx:4047
TFormula_v5.cxx:4048
TFormula_v5.cxx:4049
TFormula_v5.cxx:4050
TFormula_v5.cxx:4051
TFormula_v5.cxx:4052
TFormula_v5.cxx:4053
TFormula_v5.cxx:4054
TFormula_v5.cxx:4055
TFormula_v5.cxx:4056
TFormula_v5.cxx:4057
TFormula_v5.cxx:4058
TFormula_v5.cxx:4059
TFormula_v5.cxx:4060
TFormula_v5.cxx:4061
TFormula_v5.cxx:4062
TFormula_v5.cxx:4063
TFormula_v5.cxx:4064
TFormula_v5.cxx:4065
TFormula_v5.cxx:4066
TFormula_v5.cxx:4067
TFormula_v5.cxx:4068
TFormula_v5.cxx:4069
TFormula_v5.cxx:4070
TFormula_v5.cxx:4071
TFormula_v5.cxx:4072
TFormula_v5.cxx:4073
TFormula_v5.cxx:4074
TFormula_v5.cxx:4075
TFormula_v5.cxx:4076
TFormula_v5.cxx:4077
TFormula_v5.cxx:4078
TFormula_v5.cxx:4079
TFormula_v5.cxx:4080
TFormula_v5.cxx:4081
TFormula_v5.cxx:4082
TFormula_v5.cxx:4083
TFormula_v5.cxx:4084
TFormula_v5.cxx:4085
TFormula_v5.cxx:4086
TFormula_v5.cxx:4087
TFormula_v5.cxx:4088
TFormula_v5.cxx:4089
TFormula_v5.cxx:4090
TFormula_v5.cxx:4091
TFormula_v5.cxx:4092
TFormula_v5.cxx:4093
TFormula_v5.cxx:4094
TFormula_v5.cxx:4095
TFormula_v5.cxx:4096
TFormula_v5.cxx:4097
TFormula_v5.cxx:4098
TFormula_v5.cxx:4099
TFormula_v5.cxx:4100
TFormula_v5.cxx:4101
TFormula_v5.cxx:4102
TFormula_v5.cxx:4103
TFormula_v5.cxx:4104
TFormula_v5.cxx:4105
TFormula_v5.cxx:4106
TFormula_v5.cxx:4107
TFormula_v5.cxx:4108
TFormula_v5.cxx:4109
TFormula_v5.cxx:4110
TFormula_v5.cxx:4111
TFormula_v5.cxx:4112
TFormula_v5.cxx:4113
TFormula_v5.cxx:4114
TFormula_v5.cxx:4115
TFormula_v5.cxx:4116
TFormula_v5.cxx:4117
TFormula_v5.cxx:4118
TFormula_v5.cxx:4119
TFormula_v5.cxx:4120
TFormula_v5.cxx:4121
TFormula_v5.cxx:4122
TFormula_v5.cxx:4123
TFormula_v5.cxx:4124
TFormula_v5.cxx:4125
TFormula_v5.cxx:4126
TFormula_v5.cxx:4127
TFormula_v5.cxx:4128
TFormula_v5.cxx:4129
TFormula_v5.cxx:4130
TFormula_v5.cxx:4131
TFormula_v5.cxx:4132
TFormula_v5.cxx:4133
TFormula_v5.cxx:4134
TFormula_v5.cxx:4135
TFormula_v5.cxx:4136
TFormula_v5.cxx:4137
TFormula_v5.cxx:4138
TFormula_v5.cxx:4139
TFormula_v5.cxx:4140
TFormula_v5.cxx:4141
TFormula_v5.cxx:4142
TFormula_v5.cxx:4143
TFormula_v5.cxx:4144
TFormula_v5.cxx:4145
TFormula_v5.cxx:4146
TFormula_v5.cxx:4147
TFormula_v5.cxx:4148
TFormula_v5.cxx:4149
TFormula_v5.cxx:4150
TFormula_v5.cxx:4151
TFormula_v5.cxx:4152
TFormula_v5.cxx:4153
TFormula_v5.cxx:4154
TFormula_v5.cxx:4155
TFormula_v5.cxx:4156
TFormula_v5.cxx:4157
TFormula_v5.cxx:4158
TFormula_v5.cxx:4159
TFormula_v5.cxx:4160
TFormula_v5.cxx:4161
TFormula_v5.cxx:4162
TFormula_v5.cxx:4163
TFormula_v5.cxx:4164
TFormula_v5.cxx:4165
TFormula_v5.cxx:4166
TFormula_v5.cxx:4167
TFormula_v5.cxx:4168
TFormula_v5.cxx:4169
TFormula_v5.cxx:4170
TFormula_v5.cxx:4171
TFormula_v5.cxx:4172
TFormula_v5.cxx:4173
TFormula_v5.cxx:4174
TFormula_v5.cxx:4175
TFormula_v5.cxx:4176
TFormula_v5.cxx:4177
TFormula_v5.cxx: