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

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

#include <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
//   For more performant access to the information, see the implementation
//   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);
      }
      gROOT->GetListOfFunctions()->Add(this);
   }
}


//______________________________________________________________________________
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
         argArr.Add(new TObjString(arg));
         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);
         }

         fFunctions.Add(method);
         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] = "+";
            actionCode = kAdd;
            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) {
                        // Error message already issued
                        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)) {
                           fAlreadyFound.SetBitNumber(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()) ) {
      ((TFormula&)obj).fFunctions.Add( fobj->Clone() );
   }
   //
   // 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;
         }

         //Sign inversion
         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) {
      Error("TFormula", "Parameter %s not found", parName);
      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);
      fLinearParts.Add(f);
   }
   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.
   // See also the next function with the same name.

   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.

   if (b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t v = b.ReadVersion(&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.

   if (b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t v = b.ReadVersion(&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);
         gROOT->GetListOfFunctions()->Add(this);
      }
     
      // 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;
   fNpar   = b.ReadArray(fParams);
   fOper = new Int_t[gMAXOP];
   fNoper  = b.ReadArray(fOper);
   fNconst = b.ReadArray(fConst);
   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;
      gROOT->GetListOfFunctions()->Add(this);
   }
   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) {
         // Sign Inversion

         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;
      }
      if (GetActionOptimized(i+1)==kAdd){
         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
      //
      if (GetActionOptimized(i+2)==kFD2 || GetActionOptimized(i+2)==kAdd ||GetActionOptimized(i+2)==kSubstract||
         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)==kAdd)       {fPredefined[i] = primitive[0];}
         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
      //
      if (GetActionOptimized(i+3)==kFD3|| (  (GetActionOptimized(i+3)==kAdd||GetActionOptimized(i+3)==kMultiply) &&
         (GetActionOptimized(i+4)==kAdd||GetActionOptimized(i+4)==kMultiply) ) ){
         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)==kAdd&&GetActionOptimized(i+1)==kAdd)      action=4;
         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;
            }
         }
         if (GetActionOptimized(i)==kAdd&&GetActionOptimized(i+1)==kMultiply) action=6;
         if (GetActionOptimized(i)==kMultiply&&GetActionOptimized(i+1)==kAdd) action=7;
         //
         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());

   //   fprintf("ROOT::v5::TFormulaPrimitive::AddFormula(new ROOT::v5::TFormulaPrimitive(\"%s::%s\",\"%s::%s\",(ROOT::v5::TFormulaPrimitive::GenFunc0)%s::%s));\n",
   //             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: