Several implementations on math expression block

1 files changed, 11763 insertions, 0 deletions

diff --git a/Project/fparser/fpoptimizer.cc b/Project/fparser/fpoptimizer.cc
new file mode 100644
index 0000000..26113c7
--- /dev/null
+++ b/Project/fparser/fpoptimizer.cc
@@ -0,0 +1,11763 @@
+/***************************************************************************\
+|* Function Parser for C++ v4.5.2                                          *|
+|*-------------------------------------------------------------------------*|
+|* Function optimizer                                                      *|
+|*-------------------------------------------------------------------------*|
+|* Copyright: Joel Yliluoma                                                *|
+|*                                                                         *|
+|* This library is distributed under the terms of the                      *|
+|* GNU Lesser General Public License version 3.                            *|
+|* (See lgpl.txt and gpl.txt for the license text.)                        *|
+\***************************************************************************/
+
+/* NOTE:
+ This file contains generated code (from the optimizer sources) and is
+ not intended to be modified by hand. If you want to modify the optimizer,
+ download the development version of the library.
+*/
+
+#include "fpconfig.hh"
+#ifdef FP_SUPPORT_OPTIMIZER
+#include "fparser.hh"
+#include "extrasrc/fptypes.hh"
+#include "extrasrc/fpaux.hh"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#define tO3 ;typedef
+#define tN3 (xP1 a)
+#define tM3 :sim i61
+#define tL3 },{{1,
+#define tK3 :if(tO2
+#define tJ3 xP1 a),
+#define tI3 {data->
+#define tH3 nW 0,
+#define tG3 {tree.x6
+#define tF3 "Found "
+#define tE3 ;for lR1
+#define tD3 stackpos
+#define tC3 .GetOpcode
+#define tB3 "dup(%u) "
+#define tA3 "%d, cost "
+#define t93 "PUSH " yR2
+#define t83 ::cout<<eZ3
+#define t73 "immed "<<
+#define t63 mFuncParsers
+#define t53 cV2{assert
+#define t43 stderr
+#define t33 sep2=" "
+#define t23 FPHASH_CONST
+#define t13 cache_needed[
+#define t03 fprintf
+#define eZ3 "Applying "
+#define eY3 FUNCTIONPARSER_INSTANTIATE_OPTIMIZE
+#define eX3 FUNCTIONPARSER_INSTANTIATE_EMPTY_OPTIMIZE
+#define eW3 HANDLE_UNARY_CONST_FUNC
+#define eV3 ,l1 0x7
+#define eU3 within,
+#define eT3 c_count
+#define eS3 s_count
+#define eR3 tI2 xT1
+#define eQ3 2)lT 2*
+#define eP3 );break
+#define eO3 ].swap(
+#define eN3 else{if(
+#define eM3 b.Value)
+#define eL3 b.Opcode
+#define eK3 FP_GetOpcodeName
+#define eJ3 =synth.
+#define eI3 codes[b
+#define eH3 whydump
+#define eG3 nparams
+#define eF3 450998,
+#define eE3 cHypot,
+#define eD3 cExp nW
+#define eC3 cAbs nW
+#define eB3 )&&p nV
+#define eA3 eO;case
+#define e93 :tree
+#define e83 false;}
+#define e73 l41 y6.
+#define e63 cAbsIf)
+#define e53 ){case
+#define e43 tQ nF==
+#define e33 =true;yH1
+#define e23 =false;
+#define e13 params
+#define e03 ].first
+#define cZ3 Ne_Mask
+#define cY3 Gt_Mask
+#define cX3 Lt_Mask
+#define cW3 opcode,
+#define cV3 public:
+#define cU3 *xB lQ1
+#define cT3 pclone
+#define cS3 info.
+#define cR3 --cU1.
+#define cQ3 eK2 2,
+#define cP3 eK2 1,
+#define cO3 cOr,l6
+#define cN3 switch nR1
+#define cM3 xG p2;p2
+#define cL3 if(op1==
+#define cK3 (tree)!=
+#define cJ3 TreeCountItem
+#define cI3 ){if(
+#define cH3 newpow
+#define cG3 tX2 lU1
+#define cF3 &&p e32
+#define cE3 )))eO lI
+#define cD3 if(xW)&&
+#define cC3 xP1 2)
+#define cB3 change
+#define cA3 133,2,
+#define c93 Needs
+#define c83 byteCode
+#define c73 nT2 a eF
+#define c63 lP1 nF==
+#define c53 factor_t
+#define c43 y7 tmp2)
+#define c33 value1
+#define c23 a));if(!
+#define c13 tM nD lD
+#define c03 cAbsNot
+#define yZ3 ::ByteCodeSynth yB
+#define yY3 break;}
+#define yX3 }switch
+#define yW3 stackptr
+#define yV3 cPow);lD
+#define yU3 .empty()
+#define yT3 cMul);xN
+#define yS3 opcodes
+#define yR3 did_muli
+#define yQ3 c4 data.
+#define yP3 &Value){
+#define yO3 yK const
+#define yN3 yY3}
+#define yM3 used[b]
+#define yL3 if(a>0){
+#define yK3 :if((i42
+#define yJ3 :{lW1 r=
+#define yI3 sizeof(
+#define yH3 cLess c9
+#define yG3 ,cExp2 nW
+#define yF3 lK 2},0,
+#define yE3 ::string
+#define yD3 return p
+#define yC3 ;}return
+#define yB3 Others
+#define yA3 param.
+#define y93 .first.
+#define y83 (yA3
+#define y73 break;yX3(
+#define y63 &param=*
+#define y53 );tmp2.n7
+#define y43 nF==cLog2&&
+#define y33 nF==cPow&&tU
+#define y23 if(xW nR
+#define y13 default:
+#define y03 x83 size()
+#define xZ3 ].data);
+#define xY3 tL));x0
+#define xX3 Ge0Lt1
+#define xW3 Gt0Le1
+#define xV3 =fp_pow(
+#define xU3 ==cOr)l9
+#define xT3 cAdd l02
+#define xS3 x62 0;b<
+#define xR3 iterator
+#define xQ3 begin();
+#define xP3 TreeSet
+#define xO3 parent
+#define xN3 insert(i
+#define xM3 newrel
+#define xL3 IsNever
+#define xK3 b_needed
+#define xJ3 cachepos
+#define xI3 half&64)
+#define xH3 half=
+#define xG3 1 y8 lX1
+#define xF3 FindPos(
+#define xE3 src_pos
+#define xD3 reserve(
+#define xC3 tree.GetHash()
+#define xB3 iT1 tree
+#define xA3 ){pow.l41
+#define x93 Params[a]
+#define x83 Params.
+#define x73 yD void
+#define x63 treeptr
+#define x53 .resize(
+#define x43 yL1 xG>&
+#define x33 t81 void
+#define x23 ImmedTag
+#define x13 yD class
+#define x03 ),child);
+#define nZ3 tmp.n7 0))
+#define nY3 ));tmp c4
+#define nX3 a,const
+#define nW3 RefCount
+#define nV3 Birth();
+#define nU3 exponent
+#define nT3 result
+#define nS3 cost_t
+#define nR3 fpdata
+#define nQ3 middle
+#define nP3 ifdata
+#define nO3 };enum
+#define nN3 );eE t71
+#define nM3 cLog2by);
+#define nL3 sqrt_cost
+#define nK3 const int
+#define nJ3 mul_count
+#define nI3 maxValue1
+#define nH3 minValue1
+#define nG3 maxValue0
+#define nF3 minValue0
+#define nE3 ValueType
+#define nD3 );}yD bool
+#define nC3 xC lU 2,
+#define nB3 const std::eQ
+#define nA3 const char*
+#define n93 x31 a-->0;)if(
+#define n83 ContainsOtherCandidates
+#define n73 ;if(half
+#define n63 ;}void
+#define n53 ,l62(1))){
+#define n43 ,const e3&
+#define n33 )n63
+#define n23 1),l62(1));
+#define n13 nT3 t6
+#define n03 nT3 eY
+#define lZ3 nT3 cT1
+#define lY3 n03 e23 if(
+#define lX3 nT3 nV
+#define lW3 nT3 e32
+#define lV3 yB nT3
+#define lU3 yI n2 0),
+#define lT3 abs_mul
+#define lS3 l8 a));
+#define lR3 pos_set
+#define lQ3 e61);}if(
+#define lP3 Rehash(iB
+#define lO3 cM ifp2);
+#define lN3 sim.x3 1,
+#define lM3 [funcno].
+#define lL3 eE1[++IP]
+#define lK3 eE1[IP]==
+#define lJ3 subtree
+#define lI3 invtree
+#define lH3 MakeHash(
+#define lG3 rulenumit
+#define lF3 (cond yY
+#define lE3 ))break;l62
+#define lD3 ;}static yE1
+#define lC3 {std::cout<<
+#define lB3 a<tree.xD
+#define lA3 cAnd,l6
+#define l93 if y83
+#define l83 (tree nF)
+#define l73 MakeEqual
+#define l63 n61,l4::
+#define l53 n61,{l4::
+#define l43 newbase
+#define l33 branch1op
+#define l23 branch2op
+#define l13 overlap
+#define l03 truth_b
+#define iZ2 truth_a
+#define iY2 found_dup
+#define iX2 cY1 xG&
+#define iW2 nQ r;r c4
+#define iV2 rangeutil
+#define iU2 Plan_Has(
+#define iT2 StackMax)
+#define iS2 const nV2
+#define iR2 namespace
+#define iQ2 ::res,b8<
+#define iP2 inverted
+#define iO2 xL3:
+#define iN2 .known&&
+#define iM2 iftree
+#define iL2 depcodes
+#define iK2 explicit
+#define iJ2 cPow,l2 0,2,
+#define iI2 cPow,xK1
+#define iH2 ,{ReplaceParams,
+#define iG2 ,eB2 7168
+#define iF2 cCosh nW
+#define iE2 VarBegin
+#define iD2 .Become(
+#define iC2 begin(),
+#define iB2 cond_add
+#define iA2 cond_mul
+#define i92 cond_and
+#define i82 mulgroup
+#define i72 leaf1
+#define i62 );synth
+#define i52 ,cEqual
+#define i42 cU3.get()){
+#define i32 )lT 3*3*
+#define i22 Optimize()
+#define i12 costree
+#define i02 sintree
+#define tZ2 leaf_count
+#define tY2 sub_params
+#define tX2 nT3.
+#define tW2 printf(
+#define tV2 swap(tmp);
+#define tU2 cbrt_count
+#define tT2 sqrt_count
+#define tS2 PlusInf
+#define tR2 Finite
+#define tQ2 (lW3
+#define tP2 tI2 n2 0),
+#define tO2 xW)){l62 tmp=
+#define tN2 l62(0.0 nR
+#define tM2 p1 cM ifp1
+#define tL2 pcall_tree
+#define tK2 after_powi
+#define tJ2 ))return
+#define tI2 );m.max.
+#define tH2 ;a<t7;++a)
+#define tG2 else{xB=new
+#define tF2 yS e83
+#define tE2 e13)
+#define tD2 grammar
+#define tC2 ,cGreater
+#define tB2 ,lB 0x12 nM
+#define tA2 cLog nW
+#define t92 0x12},{{3,
+#define t82 cNeg,lU 1,
+#define t72 ),0},{
+#define t62 .data.get(
+#define t52 data;data.
+#define t42 MakeNEqual
+#define t32 xP1 1)
+#define t22 Dump(std::
+#define t12 isInteger(
+#define t02 Comparison
+#define eZ2 ,bool abs)
+#define eY2 needs_flip
+#define eX2 (half&63)-1;
+#define eW2 value]
+#define eV2 x71 xR+1);
+#define eU2 Rule&rule,
+#define eT2 cM tree);
+#define eS2 mul_item
+#define eR2 innersub
+#define eQ2 cbrt_cost
+#define eP2 best_cost
+#define eO2 condition
+#define eN2 per_item
+#define eM2 item_type
+#define eL2 first2
+#define eK2 ,l7 0,
+#define eJ2 yI known
+#define eI2 ,o);o<<"\n";
+#define eH2 info=(*xB)[
+#define eG2 cU3=r.specs;if(r.found){
+#define eF2 cU3,info
+#define eE2 *)start_at.get();
+#define eD2 l3 18,1,
+#define eC2 cIf,eV 3,
+#define eB2 l0 2,
+#define eA2 lK 1},0,
+#define e92 .what nL1
+#define e82 tree))cN
+#define e72 ;std::vector<
+#define e62 )x02.second
+#define e52 );range.x22
+#define e42 (lS,tM)nD lD
+#define e32 .min.val
+#define e22 Decision
+#define e12 ;tree y7
+#define e02 not_tree
+#define cZ2 group_by
+#define cY2 nU3=
+#define cX2 (std::move(
+#define cW2 ->second
+#define cV2 xG&tree)
+#define cU2 targetpos
+#define cT2 eO true;}
+#define cS2 ParamSpec
+#define cR2 rhs.hash2;}
+#define cQ2 rhs.hash1
+#define cP2 struct
+#define cO2 Forget()
+#define cN2 &&cond eH))
+#define cM2 source_tree
+#define cL2 <tH,nS3>
+#define cK2 p1_evenness
+#define cJ2 isNegative(
+#define cI2 (yI val
+#define cH2 ,std::cout)
+#define cG2 neg_set
+#define cF2 cNop,cNop}}
+#define cE2 cTanh,cNop,
+#define cD2 >cP2 cG<
+#define cC2 matches
+#define cB2 .match_tree
+#define cA2 (rule,tree,info
+#define c92 cY1 void*)&
+#define c82 cGreater c9
+#define c72 l5 0,1,
+#define c62 ,cTan nW
+#define c52 .xU 2)xX cPow)
+#define c42 cCos nW
+#define c32 {data xE lO
+#define c22 +=1 eO n21;
+#define c12 negated
+#define c02 iC,1,iZ+1);
+#define yZ2 Specializer
+#define yY2 coshtree
+#define yX2 sinhtree
+#define yW2 best_score
+#define yV2 mulvalue
+#define yU2 pow_item
+#define yT2 );t9=!t9;}
+#define yS2 .push_back(
+#define yR2 ;DumpTree(
+#define yQ2 eB[c i1
+#define yP2 .IsImmed(
+#define yO2 1)yP2)
+#define yN2 PowiResult
+#define yM2 maxValue
+#define yL2 minValue
+#define yK2 fp_min(yH,
+#define yJ2 yI set(fp_floor
+#define yI2 fp_max(yH)
+#define yH2 div_tree
+#define yG2 pow_tree
+#define yF2 preserve
+#define yE2 xP1 a).xE1
+#define yD2 cLog);sim.xU
+#define yC2 PullResult()
+#define yB2 dup_or_fetch
+#define yA2 nominator]
+#define y92 test_order
+#define y82 TopLevel)
+#define y72 ].info=info;
+#define y62 ):start_at()
+#define y52 .param_count
+#define y42 minimum_need
+#define y32 shift(index)
+#define y22 ,tree xA
+#define y12 rulenumber
+#define y02 cLessOrEq c9
+#define xZ2 cTan l3 2,1,
+#define xY2 cLog l3 2,1,
+#define xX2 cTanh nW
+#define xW2 ,cSinh nW
+#define xV2 cInv,lU 1,
+#define xU2 constraints=
+#define xT2 GetDepth()
+#define xS2 factor_immed
+#define xR2 changes
+#define xQ2 n11 cM y6 l8
+#define xP2 cM cond l8
+#define xO2 ,cGreaterOrEq
+#define xN2 l8 0));
+#define xM2 y7 mul);
+#define xL2 for(typename
+#define xK2 exp_diff
+#define xJ2 ExponentInfo
+#define xI2 lower_bound(
+#define xH2 factor
+#define xG2 is_logical
+#define xF2 newrel_and
+#define xE2 ;iC.Remember(
+#define xD2 eO Unknown;}
+#define xC2 res_stackpos
+#define xB2 half_pos
+#define xA2 ){half&=127;
+#define x92 {e3 start_at;
+#define x82 i52,eB2
+#define x72 (size_t
+#define x62 for x72 b=
+#define x52 >>1)):(
+#define x42 CodeTreeData
+#define x32 nU3)
+#define x22 multiply(
+#define x12 var_trees
+#define x02 parampair
+#define nZ2 ,cPow,l2 2,2,
+#define nY2 ,nM2 2,1,
+#define nX2 std::vector<xG>
+#define nW2 nE OPCODE
+#define nV2 CodeTree&
+#define nU2 parent_opcode
+#define nT2 =GetParam(
+#define nS2 changed=true;
+#define nR2 log2_exponent
+#define nQ2 tmp y7 tree);
+#define nP2 nQ tmp;tmp c4
+#define nO2 dup_fetch_pos
+#define nN2 xL3 c5 lD
+#define nM2 cPow l3
+#define nL2 cSin nW
+#define nK2 Value_EvenInt
+#define nJ2 MakeFalse,{l4
+#define nI2 if(y2 l8 a)xI
+#define nH2 AddCollection
+#define nG2 ConditionType
+#define nF2 DUP_ONE(apos)
+#define nE2 ,0,0x4 tL3
+#define nD2 (unsigned
+#define nC2 cY|nD2)
+#define nB2 SpecialOpcode
+#define nA2 sim.Eat(1,
+#define n92 ;sim.Push(
+#define n82 c4 tree nF);
+#define n72 for x72 a=
+#define n62 .UseGetNeeded(
+#define n52 ));TriTruthValue
+#define n42 synth.AddOperation(
+#define n32 ,eR,synth);
+#define n22 =i cW2.
+#define n12 IsDefined()
+#define n02 .GetHash().
+#define lZ2 assimilated
+#define lY2 );sim.x3 2,
+#define lX2 denominator
+#define lW2 fraction
+#define lV2 DUP_BOTH();
+#define lU2 template lM
+#define lT2 -1-offset].
+#define lS2 if(synth.Find(
+#define lR2 IsDescendantOf
+#define lQ2 TreeCounts
+#define lP2 ;tree.DelParam(
+#define lO2 IsImmed()cI3
+#define lN2 bool t9 e23
+#define lM2 SetOpcode(
+#define lL2 found_log2
+#define lK2 div_params
+#define lJ2 immed_sum
+#define lI2 OPCODE(opcode)
+#define lH2 break;nT3*=
+#define lG2 FactorStack yB
+#define lF2 Rehash(false);
+#define lE2 IsAlways c5 lD
+#define lD2 282870 x9
+#define lC2 cNotNot nW
+#define lB2 replacing_slot
+#define lA2 RefParams
+#define l92 if_always[
+#define l82 WhatDoWhenCase
+#define l72 exponent_immed
+#define l62 Value_t
+#define l52 );x0 l4::
+#define l42 GetOpcode())
+#define l32 );goto do_return;
+#define l22 {if(GetOpcode()
+#define l12 CollectionSet yB
+#define l02 ||op1==
+#define iZ1 yF DelParams()
+#define iY1 .SetParamsMove(
+#define iX1 data[a].second
+#define iW1 if(newrel_or==
+#define iV1 eA 2,131,
+#define iU1 Immed.size());
+#define iT1 const xG&
+#define iS1 OptimizedUsing
+#define iR1 Var_or_Funcno
+#define iQ1 iR1;
+#define iP1 GetParams(
+#define iO1 crc32_t
+#define iN1 signed_chain
+#define iM1 MinusInf
+#define iL1 n_immeds
+#define iK1 stack.size()
+#define iJ1 std::cout<<"POP "
+#define iI1 FindClone(xN
+#define iH1 needs_rehash
+#define iG1 AnyWhere_Rec
+#define iF1 ~unsigned(0)
+#define iE1 41,42,43,44,
+#define iD1 p1_logical_b
+#define iC1 p0_logical_b
+#define iB1 p1_logical_a
+#define iA1 p0_logical_a
+#define i91 divgroup
+#define i81 else if(
+#define i71 {case IsAlways:
+#define i61 .xU l62(
+#define i51 ,l5 2,1,
+#define i41 ,1,2,1,4,1,2,
+#define i31 }break cT1
+#define i21 tree nF==
+#define i11 func(val);nJ1
+#define i01 *const func)
+#define tZ1 synth.DoDup(
+#define tY1 cache_needed
+#define tX1 eA 2,1,eA 2,
+#define tW1 [nP3.ofs+
+#define tV1 treelist
+#define tU1 has_bad_balance
+#define tT1 c53 xH2
+#define tS1 fp_abs(max.val))
+#define tR1 )eO m cT1
+#define tQ1 fp_abs(min.val)
+#define tP1 cNEqual
+#define tO1 tP 2},0,0x0},{{
+#define tN1 Oneness_NotOne|
+#define tM1 Value_IsInteger
+#define tL1 Constness_Const
+#define tK1 DumpHashesFrom(
+#define tJ1 iS1(
+#define tI1 reltype
+#define tH1 SequenceOpcodes
+#define tG1 sep_list[
+#define tF1 ,l1 0x0},{{3,
+#define tE1 fpExponentIsTooLarge(
+#define tD1 l62(0
+#define tC1 goto fail;}
+#define tB1 ,cNot nW
+#define tA1 l1 0x4 nM
+#define t91 template<
+#define t81 lA2);
+#define t71 subgroup
+#define t61 lQ2.erase(cs_it);
+#define t51 yL1 unsigned>&eE1,size_t&IP,size_t limit,size_t y4
+#define t41 tJ2 true
+#define t31 TreeCountType yB
+#define t21 xG tmp;tmp c4
+#define t11 ;nU3
+#define t01 Value(Value::
+#define eZ1 >(l62(1),
+#define eY1 0.5))xX yV3
+#define eX1 stack[iK1-
+#define eW1 stack yS2
+#define eV1 synth.PushImmed(
+#define eU1 MaxChildDepth
+#define eT1 std::pair<It,It>
+#define eS1 cPow,lB
+#define eR1 Sign_Negative
+#define eQ1 Value_Logical
+#define eP1 new_factor_immed
+#define eO1 base_immed
+#define eN1 public e9,public std::vector<
+#define eM1 .Rehash();
+#define eL1 );y6 eM1 xG
+#define eK1 occurance_pos
+#define eJ1 exponent_hash
+#define eI1 exponent_list
+#define eH1 CollectMulGroup(
+#define eG1 source_set
+#define eF1 nU3,xP3
+#define eE1 ByteCode
+#define eD1 operator
+#define eC1 FindAndDup(tree);
+#define eB1 .yJ l62(2)));
+#define eA1 back().thenbranch
+#define e91 grammar_rules[*r]
+#define e81 ;flipped=!flipped;}
+#define e71 DelParam(a);}
+#define e61 tree.DelParam(a
+#define e51 synth.xH 1
+#define e41 ,iC n32
+#define e31 =comp.AddItem(atree
+#define e21 (long double)
+#define e11 yB())xX cMul);lD
+#define e01 tree yP2)c5
+#define cZ1 ;synth.StackTopIs(
+#define cY1 (const
+#define cX1 cY1 l62&
+#define cW1 >=tD1)
+#define cV1 iR2 FPoptimizer_Optimize
+#define cU1 NeedList
+#define cT1 ;}case
+#define cS1 ,lI2);
+#define cR1 ParamSpec_Extract
+#define cQ1 retry_anyparams_3
+#define cP1 retry_anyparams_2
+#define cO1 needlist_cached_t
+#define cN1 lK 2}nE2
+#define cM1 lK 1}nE2
+#define cL1 CodeTreeImmed yB(
+#define cK1 by_float_exponent
+#define cJ1 fp_equal(nU3
+#define cI1 new_exp
+#define cH1 end()&&i->first==
+#define cG1 return BecomeZero;
+#define cF1 return BecomeOne;
+#define cE1 if(lR.size()<=n0)
+#define cD1 addgroup
+#define cC1 ,PowiCache&iC,
+#define cB1 NewHash.hash1
+#define cA1 ;NewHash.hash2+=
+#define c91 ;eE i82);
+#define c81 found_log2by
+#define c71 nF==c03)
+#define c61 ParsePowiMuli(
+#define c51 iR1)
+#define c41 MakeNotP1,l4::
+#define c31 MakeNotP0,l4::
+#define c21 new_base_immed
+#define c11 branch1_backup
+#define c01 branch2_backup
+#define yZ1 exponent_map
+#define yY1 plain_set
+#define yX1 LightWeight(
+#define yW1 if(value
+#define yV1 goto do_return;}lD
+#define yU1 .GetParamCount()==
+#define yT1 should_regenerate=true;
+#define yS1 should_regenerate,
+#define yR1 Collection
+#define yQ1 RelationshipResult
+#define yP1 Subdivide_Combine(
+#define yO1 long value
+#define yN1 ):e9(),std::vector<
+#define yM1 ByteCodeSynth yB&synth)
+#define yL1 const std::vector<
+#define yK1 )const yS
+#define yJ1 rhs yK1 hash1
+#define yI1 best_sep_factor
+#define yH1 i81!nT3
+#define yG1 &&p nV<l62(
+#define yF1 needlist_cached
+#define yE1 inline unsigned
+#define yD1 cW3 bool pad
+#define yC1 MakesInteger(
+#define yB1 const l62&value
+#define yA1 best_sep_cost
+#define y91 MultiplicationRange
+#define y81 pihalf_limits
+#define y71 n_stacked
+#define y61 AnyParams_Rec
+#define y51 ;tree.SetParam(
+#define y41 continue;
+#define y31 Become(value l8 0))
+#define y21 PositionalParams,0}
+#define y11 always_sincostan
+#define y01 Recheck_RefCount_Div
+#define xZ1 Recheck_RefCount_Mul
+#define xY1 i82.
+#define xX1 i82;i82 c4
+#define xW1 MultiplyAndMakeLong(
+#define xV1 cMul);nZ3;tmp
+#define xU1 covers_plus1
+#define xT1 template set_if<
+#define xS1 if(synth.FindAndDup(
+#define xR1 SynthesizeParam(
+#define xQ1 xP1 a)yP2))
+#define xP1 tree l8
+#define xO1 ;std::cout<<
+#define xN1 grammar_func
+#define xM1 252421 x9 24830,
+#define xL1 cA 529654 x9
+#define xK1 l2 0,2,165888 x9
+#define xJ1 1)?(poly^(
+#define xI1 cCos l3 2,1,
+#define xH1 l1 0x12 nM
+#define xG1 Modulo_Radians},
+#define xF1 c4 cLog);tree c4 cMul);
+#define xE1 GetImmed()
+#define xD1 PositionType
+#define xC1 CollectionResult
+#define xB1 const_offset
+#define xA1 inline TriTruthValue
+#define x91 stacktop_desired
+#define x81 int mStackPtr=0;
+#define x71 SetStackTop(
+#define x61 }inline
+#define x51 FPoptimizer_ByteCode
+#define x41 );n41 0,x32;DelParam(1);
+#define x31 GetParamCount();
+#define x21 xI leaf2 l8
+#define x11 cond_type
+#define x01 fphash_value_t
+#define nZ1 Recheck_RefCount_RDiv
+#define nY1 fpEstimatePrecision(
+#define nX1 SwapLastTwoInStack();
+#define nW1 CollectMulGroup_Item(
+#define nV1 pair<l62,xP3>
+#define nU1 Rehash()e12 r);}
+#define nT1 nN x71 xR-1);
+#define nS1 covers_full_cycle
+#define nR1 (GetLogicalValue(
+#define nQ1 AssembleSequence(
+#define nP1 252180 x9 281854,
+#define nO1 {DataP slot_holder(y3[
+#define nN1 <<std::dec<<")";}
+#define nM1 :yD3 e32
+#define nL1 !=xK)if(TestCase(
+#define nK1 &&IsLogicalValue(
+#define nJ1 else*this=model;}
+#define nI1 std::pair<T1,T2>&
+#define nH1 t91 typename
+#define nG1 has_good_balance_found
+#define nF1 n_occurrences
+#define nE1 found_log2_on_exponent
+#define nD1 covers_minus1
+#define nC1 needs_resynth
+#define nB1 immed_product
+#define nA1 y73 bitmask&
+#define n91 Sign_Positive
+#define n81 {l4::MakeNotNotP1,l4::
+#define n71 {l4::MakeNotNotP0,l4::
+#define n61 ::MakeTrue
+#define n51 matched_params
+#define n41 SetParamMove(
+#define n31 CodeTreeImmed(l62(
+#define n21 Suboptimal
+#define n11 changed_if
+#define n01 n_as_tanh_param
+#define lZ1 opposite=
+#define lY1 x01(
+#define lX1 eE1.size()
+#define lW1 MatchResultType
+#define lV1 needs_sincos
+#define lU1 resulting_exponent
+#define lT1 ;p1 eM1 tree y7 p1);
+#define lS1 Unknown:y13;}
+#define lR1 nD2 a=0;a<c2;++a)
+#define lQ1 )[a].start_at
+#define lP1 GetParam(a)
+#define lO1 inverse_nominator]
+#define lN1 cSin l3 2,1,
+#define lM1 (xP1 yO2&&
+#define lL1 ,typename xG::
+#define lK1 IsImmed()){l62
+#define lJ1 AddFunctionOpcode(
+#define lI1 void FunctionParserBase
+#define lH1 SetParams(iP1));
+#define lG1 o<<"("<<std::hex<<data.
+#define lF1 IfBalanceGood(
+#define lE1 n_as_tan_param
+#define lD1 changed_exponent
+#define lC1 inverse_denominator
+#define lB1 unsigned index
+#define lA1 7168 x9 401798
+#define l91 yB(rule.repl_param_list,
+#define l81 retry_positionalparams_2
+#define l71 situation_flags&
+#define l61 518 x9 400412,
+#define l51 data.subfunc_opcode
+#define l41 CopyOnWrite();
+#define l31 PlanNtimesCache(
+#define l21 FPoptimizer_Grammar
+#define l11 static inline xG
+#define l01 GetPositivityInfo cK3
+#define iZ recursioncount
+#define iY ParamSpec_SubFunctionData
+#define iX ,cPow xZ
+#define iW xO1 std::endl;DumpHashes(
+#define iV ,2,1 i62.xT if(found[data.
+#define iU AddOperation(cInv,1,1 i62.xT}
+#define iT ]);n42
+#define iS ~size_t(0)){synth.yV
+#define iR PositionalParams_Rec
+#define iQ DumpTreeWithIndent(*this);
+#define iP switch(type e53 cond_or:
+#define iO CalculateResultBoundaries(
+#define iN t91 unsigned Compare>
+#define iM yF3 0x0 tL3
+#define iL edited_powgroup
+#define iK has_unknown_max
+#define iJ has_unknown_min
+#define iI static const range yB
+#define iH if(keep_powi
+#define iG synthed_tree
+#define iF SelectedParams,0},0,0x0},{{
+#define iE by_exponent
+#define iD collections
+#define iC cache
+#define iB )e12 p2);tree c4 iM2 nF);cN}
+#define iA goto ReplaceTreeWithOne;case
+#define i9 xB3,std::ostream&o
+#define i8 y7 comp.yY1[a].value);
+#define i7 !=xK)return l92
+#define i6 cK1.data
+#define i5 iK2 x42(
+#define i4 needs_sinhcosh
+#define i3 t72 l62(
+#define i2 MakeFalse,l4::
+#define i1 ].relationship
+#define i0 ,eE1,IP,limit,y4,stack);
+#define tZ 408964 x9 24963,
+#define tY 528504 x9 24713,
+#define tX AnyParams,0}}iH2
+#define tW [n0 e03=true;lR[n0].second
+#define tV l21::Grammar*
+#define tU powgroup l8
+#define tT }},{ProduceNewTree,2,1,
+#define tS ,l7 2,1,
+#define tR ~size_t(0)&&found[data.
+#define tQ xP1 0)
+#define tP xC AnyParams,
+#define tO iO xP1
+#define tN =tO 0));range yB
+#define tM t32.GetImmed(
+#define tL (tM))
+#define tK n31(
+#define tJ has_mulgroups_remaining
+#define tI Rehash();tY2 yS2
+#define tH int_exponent_t
+#define tG best_factor
+#define tF RootPowerTable yB::RootPowers[
+#define tE :goto ReplaceTreeWithZero;case
+#define tD MatchPositionSpec_AnyParams yB
+#define tC iR2 FPoptimizer_CodeTree
+#define tB n_as_sinh_param
+#define tA n_as_cosh_param
+#define t9 is_signed
+#define t8 nS l62(-n23
+#define t7 tree.GetParamCount()
+#define t6 .max.known
+#define t5 eM1 tree c4 i72 nF);tree.
+#define t4 iP1));xY1 Rehash();
+#define t3 result_positivity
+#define t2 biggest_minimum
+#define t1 124024 x9 139399,
+#define t0 142456 x9 141449,
+#define eZ valueType
+#define eY .min.known
+#define eX x72 a=0 tH2 if(remaining[a])
+#define eW ,cIf,l0 3,
+#define eV lB 0x4},{{
+#define eU cond_tree
+#define eT else_tree
+#define eS then_tree
+#define eR sequencing
+#define eQ string eK3(
+#define eP const iY
+#define eO ;return
+#define eN if_stack
+#define eM .max.set(fp_ceil tR1
+#define eL n_as_sin_param
+#define eK n_as_cos_param
+#define eJ PowiResolver::
+#define eI cIf l3 0,1,
+#define eH .BalanceGood
+#define eG {if(needs_cow){l41 goto
+#define eF );bool needs_cow=GetRefCount()>1;
+#define eE AddParamMove(
+#define eD back().endif_location
+#define eC x01 key
+#define eB relationships
+#define eA 130,1,
+#define e9 MatchPositionSpecBase
+#define e8 iK2 CodeTree(
+#define e7 smallest_maximum
+#define e6 }PACKED_GRAMMAR_ATTRIBUTE;
+#define e5 ReplaceTreeWithParam0;
+#define e4 factor_needs_rehashing
+#define e3 MatchPositionSpecBaseP
+#define e2 typename t31::xR3
+#define e1 fp_cosh cI2);m nV=fp_cosh(m nV);
+#define e0 {AdoptChildrenWithSameOpcode(tree);
+#define cZ cR1 yB(nT.param_list,
+#define cY );eE1 yS2 0x80000000u
+#define cX for(lG3 r=range.first;r!=range.second;++r){
+#define cW 243,244,245,246,249,250,251,253,255,256,257,258,259}};}
+#define cV ];};extern"C"{
+#define cU i9=std::cout
+#define cT 79,122,123,160,161,163,164,165,166,167,168,169,178,179,180,200,204,212,216,224,236,237,239,240,
+#define cS 27,28,29,30,31,32,33,35,36,
+#define cR const ParamSpec_SubFunction
+#define cQ const ParamSpec_ParamHolder
+#define cP }if(list y93 xE1==l62(
+#define cO otherhalf
+#define cN goto redo;
+#define cM .AddParam(
+#define cL StackState
+#define cK min iN2 p0 e32>=l62(0.0))
+#define cJ max.known e23
+#define cI l62(1.5)*fp_const_pi yB()
+#define cH CalculatePowiFactorCost(
+#define cG ImmedHashGenerator
+#define cF ::map<fphash_t,std::set<std yE3> >
+#define cE T1,typename T2>inline bool eD1()(
+#define cD has_nonlogical_values
+#define cC from_logical_context)
+#define cB AnyParams,0}},{ProduceNewTree,
+#define cA ,l2 18,2,
+#define c9 ,l2 16,2,
+#define c8 max iN2 p0 nV<=fp_const_negativezero yB())
+#define c7 x72 a=t7;a-->0;)
+#define c6 x72 a=0 tH2{
+#define c5 )return false;
+#define c4 .lM2
+#define c3 n72 y2.x31 a-->0;)
+#define c2 nT y52
+#define c1 POWI_CACHE_SIZE
+#define c0 ++IP;y41}if(lK3 yS3.
+#define yZ },{l4::xK,l4::Never},{l4::xK,l4::Never}}
+#define yY .FoundChild
+#define yX BalanceResultType
+#define yW n42 GetOpcode(),
+#define yV DoDup(found[data.
+#define yU nW3(0),Opcode(
+#define yT );void lJ1 unsigned cW3 yZ2<
+#define yS {return
+#define yR const yS data->
+#define yQ +=fp_const_twopi yB();
+#define yP n72 0;a<x31++a cI3
+#define yO MatchPositionSpec_AnyWhere
+#define yN l93 data.match_type==
+#define yM void OutFloatHex(std::ostream&o,
+#define yL paramholder_matches
+#define yK {static void lH3 nE fphash_t&NewHash,
+#define yJ AddParam(CodeTreeImmed(
+#define yI m.min.
+#define yH fp_sin(min),fp_sin(max))
+#define yG fp_const_twopi yB());if(
+#define yF ;n11 eM1 tree c4 op1);tree.
+#define yE n72 0;a<xO3.x31++a)if(
+#define yD template lY
+#define yC ComparisonSetBase::
+#define yB <l62>
+#define yA MatchPositionSpec_PositionalParams yB
+#define y9 AssembleSequence_Subdivide(
+#define y8 ]=0x80000000u|unsigned(
+#define y7 .eE
+#define y6 branch2
+#define y5 unsigned c;unsigned short l[
+#define y4 factor_stack_base
+#define y3 data->Params
+#define y2 branch1
+#define y1 MatchInfo yB&
+#define y0 const SequenceOpCode yB
+#define xZ ,lB 0x4 nM
+#define xY yR2 tree)xO1"\n";
+#define xX ;sim.Eat(2,
+#define xW tQ yP2
+#define xV ,l62(-1)))eG
+#define xU AddConst(
+#define xT StackTopIs(*this)eO;}
+#define xS {lQ2.erase(i);y41}
+#define xR StackTop
+#define xQ FPOPT_autoptr
+#define xP +=nT3 eO nT3;}yD inline l62
+#define xO int_exponent
+#define xN newnode
+#define xM eA2 0x0},{{
+#define xL has_highlevel_opcodes
+#define xK Unchanged
+#define xJ best_selected_sep
+#define xI .IsIdenticalTo(
+#define xH GetStackTop()-
+#define xG CodeTree yB
+#define xF cAnd,tX
+#define xE ->Recalculate_Hash_NoRecursion();}
+#define xD x31++a)if(ApplyGrammar(tD2,tJ3
+#define xC ,cAdd,
+#define xB position
+#define xA )){tree.FixIncompleteHashes();}
+#define x9 ,{2,
+#define x8 for c6 range yB
+#define x7 std::vector<CodeTree>
+#define x6 SetParam(0,iM2 xN2 xG p1;p1 c4
+#define x5 TestImmedConstraints y83 constraints,tree)c5
+#define x4 y53 0 nY3 cInv);tmp c43 eO
+#define x3 nX1 sim.Eat(
+#define x2 {nA2 cInv);yY3 sim.xU-1)xX yV3
+#define x1 paramholder_index
+#define x0 return true;case
+#define nZ occurance_counts
+#define nY >p=tO a));if(p.
+#define nX -->0;){iT1 powgroup=lP1;if(powgroup
+#define nW ,l0 1,
+#define nV .max.val
+#define nU const FPoptimizer_CodeTree::xG&tree
+#define nT model_tree
+#define nS return range yB(
+#define nR )){tree.ReplaceWithImmed(
+#define nQ ){xG
+#define nP ),rangehalf yB model=rangehalf yB()cI3 known
+#define nO x42 yB::x42(
+#define nN ){using iR2 FUNCTIONPARSERTYPES;
+#define nM },{{2,
+#define nL AnyParams,1},0,0x0},{{
+#define nK nX2&lA2
+#define nJ ConstantFolding_LogicCommon(tree,yC
+#define nI nH1 Ref>inline void xQ<Ref>::
+#define nH cOr,tX 16,1,
+#define nG ):data(new x42 yB(
+#define nF tC3()
+#define nE FUNCTIONPARSERTYPES::
+#define nD )l32}
+#define nC b;}};t91>cP2 Comp<nE
+#define nB t21 cPow);nZ3;tmp.yJ l62(
+#define nA xG tmp,tmp2;tmp2 c4
+#define n9 iR1(),Params(),Hash(),Depth(1),tJ1 0){}
+#define n8 SynthesizeByteCode(synth);
+#define n7 AddParam(xP1
+#define n6 while(ApplyGrammar(c92
+#define n5 GetIntegerInfo(tQ)==IsAlways)goto e5
+#define n4 e12 n11)cT2
+#define n3 lS);if(fp_nequal(tmp,tD1)nR l62(1)/tmp l32}}lD
+#define n2 xT1 cGreater>(l62(
+#define n1 DumpParams yB y83 data.param_list,yA3 data y52,o);
+#define n0 restholder_index
+#define lZ :if(ParamComparer yB()(Params[1],Params[0])){std::swap(Params[0],Params[1]);Opcode=
+#define lY <typename l62>
+#define lX xG nU3 t11 c4 cMul)t11 cM
+#define lW tL1,0x0},
+#define lV eE pow l8 1));pow.DelParam(1);pow eM1 tree.n41 0,pow);goto NowWeAreMulGroup;}
+#define lU GroupFunction,0},lW{{
+#define lT ,l62(1)/l62(
+#define lS tQ.xE1
+#define lR restholder_matches
+#define lQ cB1|=key;x01 crc=(key>>10)|(key<<(64-10))cA1((~lY1 crc))*3)^1234567;}};
+#define lP n11;n11 n82 n11 y7 tQ);n11 cM y2 l8
+#define lO yD xG::CodeTree(
+#define lN tree.SetParam(0,tQ l8 0))y51 1,CodeTreeImmed(
+#define lM lY void ByteCodeSynth yB::lJ1 unsigned cW3 yZ2<
+#define lL cMul,lU 2,
+#define lK cMul,AnyParams,
+#define lJ (xW)&&t32 yP2 nR
+#define lI iO tmp)cT1
+#define lH :cB3=comp.AddRelationship(atree l8 0),atree l8 1),yC
+#define lG cPow,l0 2
+#define lF typename l62>inline bool eD1()cX1 nX3 l62&b)yS a
+#define lE {range yB m=tO 0));
+#define lD break;case
+#define lC x73 xG::
+#define lB y21,0,
+#define lA l1 0x0 nM
+#define l9 ?0:1));xG n11;n11 n82 n11 iY1 tree.iP1));n11 eM1 tree c4
+#define l8 .GetParam(
+#define l7 cAdd,tX
+#define l6 SelectedParams,0},0,0x0 nM
+#define l5 lK 0}}iH2
+#define l4 RangeComparisonData
+#define l3 ,y21},{ProduceNewTree,
+#define l2 y21}iH2
+#define l1 cMul,SelectedParams,0},0,
+#define l0 lB 0x0},{{
+#ifdef _MSC_VER
+typedef
+unsigned
+int
+iO1;
+#else
+#include <stdint.h>
+typedef
+uint_least32_t
+iO1;
+#endif
+iR2
+crc32{enum{startvalue=0xFFFFFFFFUL,poly=0xEDB88320UL}
+;t91
+iO1
+crc>cP2
+b8{enum{b1=(crc&xJ1
+crc
+x52
+crc>>1),b2=(b1&xJ1
+b1
+x52
+b1>>1),b3=(b2&xJ1
+b2
+x52
+b2>>1),b4=(b3&xJ1
+b3
+x52
+b3>>1),b5=(b4&xJ1
+b4
+x52
+b4>>1),b6=(b5&xJ1
+b5
+x52
+b5>>1),b7=(b6&xJ1
+b6
+x52
+b6>>1),res=(b7&xJ1
+b7
+x52
+b7>>1)}
+;}
+;inline
+iO1
+update(iO1
+crc,unsigned
+b){
+#define B4(n) b8<n>iQ2 n+1>iQ2 n+2>iQ2 n+3>::res
+#define R(n) B4(n),B4(n+4),B4(n+8),B4(n+12)
+static
+const
+iO1
+table[256]={R(0x00),R(0x10),R(0x20),R(0x30),R(0x40),R(0x50),R(0x60),R(0x70),R(0x80),R(0x90),R(0xA0),R(0xB0),R(0xC0),R(0xD0),R(0xE0),R(0xF0)}
+;
+#undef R
+#undef B4
+return((crc>>8))^table[(crc^b)&0xFF];x61
+iO1
+calc_upd(iO1
+c,const
+unsigned
+char*buf,size_t
+size){iO1
+value=c;for
+x72
+p=0;p<size;++p)value=update(value,buf[p])eO
+value;x61
+iO1
+calc
+cY1
+unsigned
+char*buf,size_t
+size)yS
+calc_upd(startvalue,buf,size);}
+}
+#ifndef FPOptimizerAutoPtrHH
+#define FPOptimizerAutoPtrHH
+nH1
+Ref>class
+xQ{cV3
+xQ():p(0){}
+xQ(Ref*b):p(b){nV3}
+xQ
+cY1
+xQ&b):p(b.p){nV3
+x61
+Ref&eD1*(yK1*p;x61
+Ref*eD1->(yK1
+p;}
+bool
+isnull(yK1!p;}
+Ref*get(yK1
+p;}
+xQ&eD1=(Ref*b){Set(b)eO*this;}
+xQ&eD1=cY1
+xQ&b){Set(b.p)eO*this;}
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+xQ(xQ&&b):p(b.p){b.p=0;}
+xQ&eD1=(xQ&&b
+cI3
+p!=b.p){cO2;p=b.p;b.p=0
+yC3*this;}
+#endif
+~xQ(){cO2
+n63
+UnsafeSetP(Ref*newp){p=newp
+n63
+swap(xQ<Ref>&b){Ref*tmp=p;p=b.p;b.p=tmp;}
+private:inline
+static
+void
+Have(Ref*p2);inline
+void
+cO2;inline
+void
+nV3
+inline
+void
+Set(Ref*p2);private:Ref*p;}
+;nI
+cO2{if(!p)return;p->nW3-=1;if(!p->nW3)delete
+p;}
+nI
+Have(Ref*p2
+cI3
+p2)++(p2->nW3);}
+nI
+Birth(){Have(p);}
+nI
+Set(Ref*p2){Have(p2);cO2;p=p2;}
+#endif
+#include <utility>
+cP2
+Compare2ndRev{nH1
+T>inline
+bool
+eD1()cY1
+T&nX3
+T&b
+yK1
+a.second>b.second;}
+}
+;cP2
+Compare1st{nH1
+cE
+const
+nI1
+nX3
+nI1
+b
+yK1
+a.first<b.first;}
+nH1
+cE
+const
+nI1
+a,T1
+b
+yK1
+a.first<b;}
+nH1
+cE
+T1
+nX3
+nI1
+b
+yK1
+a<b.first;}
+}
+;
+#ifndef FPoptimizerHashHH
+#define FPoptimizerHashHH
+#ifdef _MSC_VER
+typedef
+unsigned
+long
+long
+x01;
+#define FPHASH_CONST(x) x##ULL
+#else
+#include <stdint.h>
+typedef
+uint_fast64_t
+x01;
+#define FPHASH_CONST(x) x##ULL
+#endif
+iR2
+FUNCTIONPARSERTYPES{cP2
+fphash_t{x01
+hash1,hash2;fphash_t():hash1(0),hash2(0){}
+fphash_t
+cY1
+x01&nX3
+x01&b):hash1(a),hash2(b){}
+bool
+eD1==cY1
+fphash_t&yJ1==cQ2&&hash2==cR2
+bool
+eD1!=cY1
+fphash_t&yJ1!=cQ2||hash2!=cR2
+bool
+eD1<cY1
+fphash_t&yJ1!=cQ2?hash1<cQ2:hash2<cR2}
+;}
+#endif
+#ifndef FPOptimizer_CodeTreeHH
+#define FPOptimizer_CodeTreeHH
+#ifdef FP_SUPPORT_OPTIMIZER
+#include <vector>
+#include <utility>
+iR2
+l21{cP2
+Grammar;}
+iR2
+x51{x13
+ByteCodeSynth;}
+tC{x13
+CodeTree;yD
+cP2
+x42;x13
+CodeTree{typedef
+xQ<x42
+yB>DataP;DataP
+data;cV3
+CodeTree();~CodeTree();cP2
+OpcodeTag{}
+;e8
+nW2
+o,OpcodeTag);cP2
+FuncOpcodeTag{}
+;e8
+nW2
+o,unsigned
+f,FuncOpcodeTag);cP2
+x23{}
+;e8
+const
+l62&v,x23);
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
+e8
+l62&&v,x23);
+#endif
+cP2
+VarTag{}
+;e8
+unsigned
+varno,VarTag);cP2
+CloneTag{}
+;e8
+iS2
+b,CloneTag);void
+GenerateFrom
+cY1
+typename
+FunctionParserBase
+yB::Data&data,bool
+keep_powi=false);void
+GenerateFrom
+cY1
+typename
+FunctionParserBase
+yB::Data&data,const
+x7&x12,bool
+keep_powi=false);void
+SynthesizeByteCode(std::vector<unsigned>&c83,std::vector
+yB&immed,size_t&stacktop_max);void
+SynthesizeByteCode(x51
+yZ3&synth,bool
+MustPopTemps=true)const;size_t
+SynthCommonSubExpressions(x51::yM1
+const;void
+SetParams
+cY1
+x7&x33
+SetParamsMove(x7&t81
+CodeTree
+GetUniqueRef();
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
+void
+SetParams(x7&&t81
+#endif
+void
+SetParam
+x72
+which,iS2
+b);void
+n41
+size_t
+which,nV2
+b);void
+AddParam
+cY1
+nV2
+param);void
+eE
+nV2
+param);void
+AddParams
+cY1
+x7&x33
+AddParamsMove(x7&x33
+AddParamsMove(x7&lA2,size_t
+lB2);void
+DelParam
+x72
+index);void
+DelParams();void
+Become
+cY1
+nV2
+b);inline
+size_t
+GetParamCount(yK1
+iP1).size();x61
+nV2
+GetParam
+x72
+n)yS
+iP1)[n];x61
+iS2
+GetParam
+x72
+n
+yK1
+iP1)[n];x61
+void
+lM2
+nW2
+o)tI3
+Opcode=o;x61
+nW2
+GetOpcode()yR
+Opcode;x61
+nE
+fphash_t
+GetHash()yR
+Hash;x61
+const
+x7&iP1
+yK1
+y3;x61
+x7&iP1)yS
+y3;x61
+size_t
+xT2
+yR
+Depth;x61
+const
+l62&xE1
+yR
+Value;x61
+unsigned
+GetVar()yR
+iQ1
+x61
+unsigned
+GetFuncNo()yR
+iQ1
+x61
+bool
+IsDefined(yK1
+GetOpcode()!=nE
+cNop;x61
+bool
+IsImmed(yK1
+GetOpcode()==nE
+cImmed;x61
+bool
+IsVar(yK1
+GetOpcode()==nE
+iE2;x61
+unsigned
+GetRefCount()yR
+nW3
+n63
+ReplaceWithImmed
+cX1
+i);void
+Rehash(bool
+constantfolding=true);void
+Sort();inline
+void
+Mark_Incompletely_Hashed()tI3
+Depth=0;x61
+bool
+Is_Incompletely_Hashed()yR
+Depth==0;x61
+const
+tV
+GetOptimizedUsing()yR
+iS1;x61
+void
+SetOptimizedUsing
+cY1
+tV
+g)tI3
+iS1=g;}
+bool
+RecreateInversionsAndNegations(bool
+prefer_base2=false);void
+FixIncompleteHashes();void
+swap(nV2
+b){data.swap(b.data);}
+bool
+IsIdenticalTo
+cY1
+nV2
+b)const;void
+l41}
+;yD
+cP2
+x42{int
+nW3;nW2
+Opcode;l62
+Value;unsigned
+iQ1
+nX2
+Params;nE
+fphash_t
+Hash;size_t
+Depth;const
+tV
+iS1;x42();x42
+cY1
+x42&b);i5
+nW2
+o);i5
+nW2
+o,unsigned
+f);i5
+const
+l62&i);
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
+i5
+l62&&i);x42(x42&&b);
+#endif
+bool
+IsIdenticalTo
+cY1
+x42&b)const;void
+Sort();void
+Recalculate_Hash_NoRecursion();private:void
+eD1=cY1
+x42&b);}
+;yD
+l11
+CodeTreeImmed
+cX1
+i)yS
+xG(i
+lL1
+x23());}
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
+yD
+l11
+CodeTreeImmed(l62&&i)yS
+xG
+cX2
+i)lL1
+x23());}
+#endif
+yD
+l11
+CodeTreeOp(nW2
+opcode)yS
+xG(opcode
+lL1
+OpcodeTag());}
+yD
+l11
+CodeTreeFuncOp(nW2
+cW3
+unsigned
+f)yS
+xG(cW3
+f
+lL1
+FuncOpcodeTag());}
+yD
+l11
+CodeTreeVar
+nD2
+varno)yS
+xG(varno
+lL1
+VarTag());}
+#ifdef FUNCTIONPARSER_SUPPORT_DEBUGGING
+x73
+DumpHashes(cU);x73
+DumpTree(cU);x73
+DumpTreeWithIndent(cU,const
+std
+yE3&indent="\\"
+);
+#endif
+}
+#endif
+#endif
+#ifndef FPOptimizer_GrammarHH
+#define FPOptimizer_GrammarHH
+#include <iostream>
+tC{x13
+CodeTree;}
+iR2
+l21{enum
+ImmedConstraint_Value{ValueMask=0x07,Value_AnyNum=0x0,nK2=0x1,Value_OddInt=0x2,tM1=0x3,Value_NonInteger=0x4,eQ1=0x5
+nO3
+ImmedConstraint_Sign{SignMask=0x18,Sign_AnySign=0x00,n91=0x08,eR1=0x10,Sign_NoIdea=0x18
+nO3
+ImmedConstraint_Oneness{OnenessMask=0x60,Oneness_Any=0x00,Oneness_One=0x20,Oneness_NotOne=0x40
+nO3
+ImmedConstraint_Constness{ConstnessMask=0x180,Constness_Any=0x00,tL1=0x80,Constness_NotConst=0x100
+nO3
+Modulo_Mode{Modulo_None=0,Modulo_Radians=1
+nO3
+Situation_Flags{LogicalContextOnly=0x01,NotForIntegers=0x02,OnlyForIntegers=0x04,OnlyForComplex=0x08,NotForComplex=0x10
+nO3
+nB2{NumConstant,ParamHolder,SubFunction
+nO3
+ParamMatchingType{PositionalParams,SelectedParams,AnyParams,GroupFunction
+nO3
+RuleType{ProduceNewTree,ReplaceParams}
+;
+#ifdef __GNUC__
+# define PACKED_GRAMMAR_ATTRIBUTE __attribute__((packed))
+#else
+# define PACKED_GRAMMAR_ATTRIBUTE
+#endif
+typedef
+std::pair<nB2,const
+void*>cS2;yD
+cS2
+cR1
+nD2
+paramlist,lB1);yD
+bool
+ParamSpec_Compare
+cY1
+void*nX3
+void*b,nB2
+type);unsigned
+ParamSpec_GetDepCode
+cY1
+cS2&b);cP2
+ParamSpec_ParamHolder{lB1:8;unsigned
+constraints:9;unsigned
+depcode:15;e6
+yD
+cP2
+ParamSpec_NumConstant{l62
+constvalue;unsigned
+modulo;}
+;cP2
+iY{unsigned
+param_count:2;unsigned
+param_list:30;nW2
+subfunc_opcode:8;ParamMatchingType
+match_type:3;unsigned
+n0:5;e6
+cP2
+ParamSpec_SubFunction{iY
+data;unsigned
+constraints:9;unsigned
+depcode:7;e6
+cP2
+Rule{RuleType
+ruletype:2;unsigned
+situation_flags:5;unsigned
+repl_param_count:2+9;unsigned
+repl_param_list:30;iY
+match_tree;e6
+cP2
+Grammar{unsigned
+rule_count;unsigned
+short
+rule_list[999
+cV
+extern
+const
+Rule
+grammar_rules[];}
+x73
+DumpParam
+cY1
+cS2&p,std::ostream&o=std::cout);x73
+DumpParams
+nD2
+paramlist,unsigned
+count,std::ostream&o=std::cout);}
+#endif
+#ifndef M_PI
+#define M_PI 3.1415926535897932384626433832795
+#endif
+#define CONSTANT_POS_INF HUGE_VAL
+#define CONSTANT_NEG_INF (-HUGE_VAL)
+iR2
+FUNCTIONPARSERTYPES{yD
+inline
+l62
+fp_const_pihalf()yS
+fp_const_pi
+yB()*l62(0.5);}
+yD
+inline
+l62
+fp_const_twopi(){l62
+nT3(fp_const_pi
+yB());nT3
+xP
+fp_const_twoe(){l62
+nT3(fp_const_e
+yB());nT3
+xP
+fp_const_twoeinv(){l62
+nT3(fp_const_einv
+yB());nT3
+xP
+fp_const_negativezero()yS-Epsilon
+yB::value;}
+}
+#ifdef FP_SUPPORT_OPTIMIZER
+#include <vector>
+#include <utility>
+#include <iostream>
+cV1{using
+iR2
+l21;using
+tC;using
+iR2
+FUNCTIONPARSERTYPES;x13
+MatchInfo{cV3
+std::vector<std::pair<bool,nX2> >lR;nX2
+yL
+e72
+unsigned>n51;cV3
+MatchInfo():lR(),yL(),n51(){}
+cV3
+bool
+SaveOrTestRestHolder
+nD2
+n0,x43
+tV1){cE1{lR
+x53
+n0+1);lR
+tW=tV1
+cT2
+if(lR[n0
+e03==false){lR
+tW=tV1
+cT2
+x43
+found=lR[n0].second;if(tV1.size()!=found.size()c5
+n72
+0;a<tV1.size();++a)if(!tV1[a]xI
+found[a])c5
+return
+true
+n63
+SaveRestHolder
+nD2
+n0,nX2&tV1){cE1
+lR
+x53
+n0+1);lR
+tW.swap(tV1);}
+bool
+SaveOrTestParamHolder
+nD2
+x1,iT1
+x63
+cI3
+yL.size()<=x1){yL.xD3
+x1+1);yL
+x53
+x1);yL
+yS2
+x63)cT2
+if(!yL[x1].n12){yL[x1]=x63
+cT2
+return
+x63
+xI
+yL[x1]n33
+SaveMatchedParamIndex(lB1){n51
+yS2
+index);}
+iT1
+GetParamHolderValueIfFound
+nD2
+x1)const{static
+const
+xG
+dummytree;if(yL.size()<=x1)return
+dummytree
+eO
+yL[x1];}
+iT1
+GetParamHolderValue
+nD2
+x1
+yK1
+yL[x1];}
+bool
+HasRestHolder
+nD2
+n0
+yK1
+lR.size()>n0&&lR[n0
+e03==true;}
+x43
+GetRestHolderValues
+nD2
+n0)const{static
+yL1
+xG>empty_result;cE1
+return
+empty_result
+eO
+lR[n0].second;}
+yL1
+unsigned>&GetMatchedParamIndexes(yK1
+n51
+n63
+swap(y1
+b){lR.swap(b.lR);yL.swap(b.yL);n51.swap(b.n51);}
+y1
+eD1=cY1
+y1
+b){lR=b.lR;yL=b.yL;n51=b.n51
+eO*this;}
+}
+;class
+e9
+tO3
+xQ<e9>e3;class
+e9{cV3
+int
+nW3;cV3
+e9():nW3(0){}
+virtual~e9(){}
+}
+;cP2
+lW1{bool
+found;e3
+specs;lW1(bool
+f):found(f),specs(){}
+lW1(bool
+f
+n43
+s):found(f),specs(s){}
+}
+;x73
+SynthesizeRule
+cY1
+eU2
+xG&tree,y1
+info);yD
+lW1
+TestParam
+cY1
+cS2&x02,xB3
+n43
+start_at,y1
+info);yD
+lW1
+TestParams(eP&nT,xB3
+n43
+start_at,y1
+info,bool
+y82;yD
+bool
+ApplyGrammar
+cY1
+Grammar&tD2,FPoptimizer_CodeTree::xG&tree,bool
+from_logical_context=false);x73
+ApplyGrammars(FPoptimizer_CodeTree::cV2;yD
+bool
+IsLogisticallyPlausibleParamsMatch(eP&e13,xB3);}
+iR2
+l21{x73
+DumpMatch
+cY1
+eU2
+nU,const
+FPoptimizer_Optimize::y1
+info,bool
+DidMatch,std::ostream&o=std::cout);x73
+DumpMatch
+cY1
+eU2
+nU,const
+FPoptimizer_Optimize::y1
+info,nA3
+eH3,std::ostream&o=std::cout);}
+#endif
+#include <string>
+nB3
+l21::nB2
+yD1=false);nB3
+nW2
+yD1=false);
+#include <string>
+#include <sstream>
+#include <assert.h>
+#include <iostream>
+using
+iR2
+l21;using
+iR2
+FUNCTIONPARSERTYPES;nB3
+l21::nB2
+yD1){
+#if 1
+nA3
+p=0;switch(opcode
+e53
+NumConstant:p="NumConstant"
+;lD
+ParamHolder:p="ParamHolder"
+;lD
+SubFunction:p="SubFunction"
+;yY3
+std::ostringstream
+tmp;assert(p);tmp<<p;if(pad)while(tmp.str().size()<12)tmp<<' '
+eO
+tmp.str();
+#else
+std::ostringstream
+tmp;tmp<<opcode;if(pad)while(tmp.str().size()<5)tmp<<' '
+eO
+tmp.str();
+#endif
+}
+nB3
+nW2
+yD1){
+#if 1
+nA3
+p=0;switch(opcode
+e53
+cAbs:p="cAbs"
+;lD
+cAcos:p="cAcos"
+;lD
+cAcosh:p="cAcosh"
+;lD
+cArg:p="cArg"
+;lD
+cAsin:p="cAsin"
+;lD
+cAsinh:p="cAsinh"
+;lD
+cAtan:p="cAtan"
+;lD
+cAtan2:p="cAtan2"
+;lD
+cAtanh:p="cAtanh"
+;lD
+cCbrt:p="cCbrt"
+;lD
+cCeil:p="cCeil"
+;lD
+cConj:p="cConj"
+;lD
+cCos:p="cCos"
+;lD
+cCosh:p="cCosh"
+;lD
+cCot:p="cCot"
+;lD
+cCsc:p="cCsc"
+;lD
+cExp:p="cExp"
+;lD
+cExp2:p="cExp2"
+;lD
+cFloor:p="cFloor"
+;lD
+cHypot:p="cHypot"
+;lD
+cIf:p="cIf"
+;lD
+cImag:p="cImag"
+;lD
+cInt:p="cInt"
+;lD
+cLog:p="cLog"
+;lD
+cLog2:p="cLog2"
+;lD
+cLog10:p="cLog10"
+;lD
+cMax:p="cMax"
+;lD
+cMin:p="cMin"
+;lD
+cPolar:p="cPolar"
+;lD
+cPow:p="cPow"
+;lD
+cReal:p="cReal"
+;lD
+cSec:p="cSec"
+;lD
+cSin:p="cSin"
+;lD
+cSinh:p="cSinh"
+;lD
+cSqrt:p="cSqrt"
+;lD
+cTan:p="cTan"
+;lD
+cTanh:p="cTanh"
+;lD
+cTrunc:p="cTrunc"
+;lD
+cImmed:p="cImmed"
+;lD
+cJump:p="cJump"
+;lD
+cNeg:p="cNeg"
+;lD
+cAdd:p="cAdd"
+;lD
+cSub:p="cSub"
+;lD
+cMul:p="cMul"
+;lD
+cDiv:p="cDiv"
+;lD
+cMod:p="cMod"
+;lD
+cEqual:p="cEqual"
+;lD
+tP1:p="cNEqual"
+;lD
+cLess:p="cLess"
+;lD
+cLessOrEq:p="cLessOrEq"
+;lD
+cGreater:p="cGreater"
+;lD
+cGreaterOrEq:p="cGreaterOrEq"
+;lD
+cNot:p="cNot"
+;lD
+cAnd:p="cAnd"
+;lD
+cOr:p="cOr"
+;lD
+cDeg:p="cDeg"
+;lD
+cRad:p="cRad"
+;lD
+cFCall:p="cFCall"
+;lD
+cPCall:p="cPCall"
+;break;
+#ifdef FP_SUPPORT_OPTIMIZER
+case
+cFetch:p="cFetch"
+;lD
+cPopNMov:p="cPopNMov"
+;lD
+cLog2by:p="cLog2by"
+;lD
+cNop:p="cNop"
+;break;
+#endif
+case
+cSinCos:p="cSinCos"
+;lD
+cSinhCosh:p="cSinhCosh"
+;lD
+c03:p="cAbsNot"
+;lD
+cAbsNotNot:p="cAbsNotNot"
+;lD
+cAbsAnd:p="cAbsAnd"
+;lD
+cAbsOr:p="cAbsOr"
+;lD
+cAbsIf:p="cAbsIf"
+;lD
+cDup:p="cDup"
+;lD
+cInv:p="cInv"
+;lD
+cSqr:p="cSqr"
+;lD
+cRDiv:p="cRDiv"
+;lD
+cRSub:p="cRSub"
+;lD
+cNotNot:p="cNotNot"
+;lD
+cRSqrt:p="cRSqrt"
+;lD
+iE2:p="VarBegin"
+;yY3
+std::ostringstream
+tmp;assert(p);tmp<<p;if(pad)while(tmp.str().size()<12)tmp<<' '
+eO
+tmp.str();
+#else
+std::ostringstream
+tmp;tmp<<opcode;if(pad)while(tmp.str().size()<5)tmp<<' '
+eO
+tmp.str();
+#endif
+}
+#ifdef FP_SUPPORT_OPTIMIZER
+#include <vector>
+#include <utility>
+#ifndef FP_GENERATING_POWI_TABLE
+enum{MAX_POWI_BYTECODE_LENGTH=20}
+;
+#else
+enum{MAX_POWI_BYTECODE_LENGTH=999}
+;
+#endif
+enum{MAX_MULI_BYTECODE_LENGTH=3}
+;iR2
+x51{x13
+ByteCodeSynth{cV3
+ByteCodeSynth():eE1(),Immed(),cL(),xR(0),StackMax(0){eE1.xD3
+64);Immed.xD3
+8);cL.xD3
+16
+n33
+Pull(std::vector<unsigned>&bc,std::vector
+yB&imm,size_t&StackTop_max){for
+nD2
+a=0;a<lX1;++a){eE1[a]&=~0x80000000u;}
+eE1.swap(bc);Immed.swap(imm);StackTop_max=StackMax;}
+size_t
+GetByteCodeSize(yK1
+lX1;}
+size_t
+GetStackTop(yK1
+xR
+n63
+PushVar
+nD2
+varno){eE1
+yS2
+varno);eV2}
+void
+PushImmed(l62
+immed
+nN
+eE1
+yS2
+cImmed);Immed
+yS2
+immed);eV2}
+void
+StackTopIs(nU,int
+offset=0
+cI3(int)xR>offset){cL[xR
+lT2
+first=true;cL[xR
+lT2
+second=tree;}
+}
+bool
+IsStackTop(nU,int
+offset=0
+yK1(int)xR>offset&&cL[xR
+lT2
+first&&cL[xR
+lT2
+second
+xI
+tree);x61
+void
+EatNParams
+nD2
+eat_count){xR-=eat_count
+n63
+ProducedNParams
+nD2
+produce_count){x71
+xR+produce_count
+n33
+DoPopNMov
+x72
+cU2,size_t
+srcpos
+nN
+eE1
+yS2
+cPopNMov
+nC2
+cU2
+nC2
+srcpos);x71
+srcpos+1);cL[cU2]=cL[srcpos];x71
+cU2+1
+n33
+DoDup
+x72
+xE3
+nN
+if(xE3==xR-1){eE1
+yS2
+cDup);}
+else{eE1
+yS2
+cFetch
+nC2
+xE3);}
+eV2
+cL[xR-1]=cL[xE3];}
+#ifdef FUNCTIONPARSER_SUPPORT_DEBUGGING
+t91
+int>void
+Dump(){std::ostream&o=std::cout;o<<"Stack state now("
+<<xR<<"):\n"
+;n72
+0;a<xR;++a){o<<a<<": "
+;if(cL[a
+e03){nU=cL[a].second;o<<'['<<std::hex<<(void*)(&tree.iP1))<<std::dec<<','<<tree.GetRefCount()<<']'
+yR2
+tree,o);}
+else
+o<<"?"
+;o<<"\n"
+;}
+o<<std::flush;}
+#endif
+size_t
+xF3
+nU)const{n72
+xR;a-->0;)if(cL[a
+e03&&cL[a].second
+xI
+tree
+tJ2
+a
+eO~size_t(0);}
+bool
+Find(nU
+yK1
+xF3
+tree)!=~size_t(0);}
+bool
+FindAndDup(nU){size_t
+pos=xF3
+tree);if(pos!=~size_t(0)){
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<tF3"duplicate at ["
+<<pos<<"]: "
+yR2
+tree)xO1" -- issuing cDup or cFetch\n"
+;
+#endif
+DoDup(pos)cT2
+return
+e83
+cP2
+IfData{size_t
+ofs;}
+;void
+SynthIfStep1(IfData&nP3,nW2
+op
+nT1
+nP3.ofs=lX1;eE1
+yS2
+op
+cY
+cY
+n33
+SynthIfStep2(IfData&nP3
+nT1
+eE1
+tW1
+xG3+2);eE1
+tW1
+2
+y8
+iU1
+nP3.ofs=lX1;eE1
+yS2
+cJump
+cY
+cY
+n33
+SynthIfStep3(IfData&nP3
+nT1
+eE1.back()|=0x80000000u;eE1
+tW1
+xG3-1);eE1
+tW1
+2
+y8
+iU1
+eV2
+n72
+0;a<nP3.ofs;++a
+cI3
+eE1[a]==cJump&&eE1[a+1]==(0x80000000u|(nP3.ofs-1))){eE1[a+xG3-1);eE1[a+2
+y8
+iU1
+yX3(eE1[a]e53
+cAbsIf:case
+cIf:case
+cJump:case
+cPopNMov:a+=2;lD
+cFCall:case
+cPCall:case
+cFetch:a+=1;break;y13
+yN3}
+protected:void
+x71
+size_t
+value){xR=value;if(xR>iT2{StackMax=xR;cL
+x53
+iT2;}
+}
+protected:std::vector<unsigned>eE1;std::vector
+yB
+Immed
+e72
+std::pair<bool,FPoptimizer_CodeTree::xG> >cL;size_t
+xR;size_t
+StackMax;private:void
+incStackPtr(){if(xR+2>iT2
+cL
+x53
+StackMax=xR+2);}
+t91
+bool
+IsIntType,bool
+IsComplexType>cP2
+yZ2{}
+;cV3
+void
+AddOperation
+nD2
+cW3
+unsigned
+eat_count,unsigned
+produce_count=1){EatNParams(eat_count);lJ1
+opcode);ProducedNParams(produce_count
+n33
+lJ1
+unsigned
+cW3
+yZ2<false,false>yT
+false,true>yT
+true,false>yT
+true,true>);inline
+void
+lJ1
+unsigned
+opcode){lJ1
+cW3
+yZ2<bool(nE
+IsIntType
+yB::nT3),bool(nE
+IsComplexType
+yB::nT3)>());}
+}
+;yD
+cP2
+SequenceOpCode;yD
+cP2
+tH1{static
+y0
+AddSequence;static
+y0
+MulSequence;}
+;x73
+nQ1
+long
+count,y0&eR,yM1;}
+#endif
+#ifdef FP_SUPPORT_OPTIMIZER
+using
+iR2
+FUNCTIONPARSERTYPES;iR2
+x51{yD
+cP2
+SequenceOpCode{l62
+basevalue;unsigned
+op_flip;unsigned
+op_normal,op_normal_flip;unsigned
+op_inverse,op_inverse_flip;}
+;yD
+y0
+tH1
+yB::AddSequence={tD1),cNeg
+xC
+cAdd,cSub,cRSub}
+;yD
+y0
+tH1
+yB::MulSequence={l62(1),cInv,cMul,cMul,cDiv,cRDiv}
+;
+#define findName(a,b,c) "var"
+#define TryCompilePowi(o) false
+#define mData this
+#define mByteCode eE1
+#define mImmed Immed
+lU2
+false,false>){x81
+# define FP_FLOAT_VERSION 1
+# define FP_COMPLEX_VERSION 0
+# include "extrasrc/fp_opcode_add.inc"
+# undef FP_COMPLEX_VERSION
+# undef FP_FLOAT_VERSION
+}
+lU2
+true,false>){x81
+# define FP_FLOAT_VERSION 0
+# define FP_COMPLEX_VERSION 0
+# include "extrasrc/fp_opcode_add.inc"
+# undef FP_COMPLEX_VERSION
+# undef FP_FLOAT_VERSION
+}
+#ifdef FP_SUPPORT_COMPLEX_NUMBERS
+lU2
+false,true>){x81
+# define FP_FLOAT_VERSION 1
+# define FP_COMPLEX_VERSION 1
+# include "extrasrc/fp_opcode_add.inc"
+# undef FP_COMPLEX_VERSION
+# undef FP_FLOAT_VERSION
+}
+lU2
+true,true>){x81
+# define FP_FLOAT_VERSION 0
+# define FP_COMPLEX_VERSION 1
+# include "extrasrc/fp_opcode_add.inc"
+# undef FP_COMPLEX_VERSION
+# undef FP_FLOAT_VERSION
+}
+#endif
+#undef findName
+#undef mImmed
+#undef mByteCode
+#undef mData
+#undef TryCompilePowi
+}
+using
+iR2
+x51;
+#define POWI_TABLE_SIZE 256
+#define POWI_WINDOW_SIZE 3
+iR2
+x51{
+#ifndef FP_GENERATING_POWI_TABLE
+extern
+const
+unsigned
+char
+powi_table[POWI_TABLE_SIZE];const
+#endif
+unsigned
+char
+powi_table[POWI_TABLE_SIZE]={0,1,1,1,2
+i41
+1,4,1,2,131,8
+i41
+1,8,cA3
+131,4,1,15,1,16
+i41
+131,8,1,2,1,4,cA3
+1,16,1,25,131,4,1,27,5,8,3,2,1,30,1,31,3,32
+i41
+1,8,1,2,131,4,1,39,1,16,137,2,1,4,cA3
+131,8,1,45,135,4,31,2,5,32,1,2,131,50,1,51,1,8,3,2,1,54,1,55,3,16,1,57,133,4,137,2,135,60,1,61,3,62,133,63,1,tX1
+131,tX1
+139,iV1
+eA
+30,1,130,137,2,31,iV1
+eA
+eA
+130,cA3
+1,eA
+eA
+2,1,130,133,tX1
+61,130,133,62,139,130,137,eA
+iV1
+eA
+eA
+tX1
+131,eA
+eA
+130,131,2,133,iV1
+130,141,eA
+130,cA3
+1,eA
+5,135,eA
+iV1
+eA
+iV1
+130,133,130,141,130,131,eA
+eA
+2,131}
+;}
+static
+nK3
+c1=256;
+#define FPO(x)
+iR2{class
+PowiCache{private:int
+iC[c1];int
+tY1[c1];cV3
+PowiCache():iC(),tY1(){iC[1]=1;}
+bool
+Plan_Add(yO1,int
+count){yW1>=c1
+c5
+tY1[eW2+=count
+eO
+iC[eW2!=0
+n63
+iU2
+yO1){yW1<c1)iC[eW2=1
+n63
+Start
+x72
+value1_pos){for(int
+n=2;n<c1;++n)iC[n]=-1;Remember(1,value1_pos);DumpContents();}
+int
+Find(yO1)const{yW1<c1
+cI3
+iC[eW2>=0){FPO(t03(t43,"* I found %ld from cache (%u,%d)\n",value,(unsigned)cache[value],t13 value]))eO
+iC[eW2;}
+}
+return-1
+n63
+Remember(yO1,size_t
+tD3){yW1>=c1)return;FPO(t03(t43,"* Remembering that %ld can be found at %u (%d uses remain)\n",value,(unsigned)tD3,t13 value]));iC[eW2=(int)tD3
+n63
+DumpContents()const{FPO(for(int a=1;a<POWI_CACHE_SIZE;++a)if(cache[a]>=0||t13 a]>0){t03(t43,"== cache: sp=%d, val=%d, needs=%d\n",cache[a],a,t13 a]);})}
+int
+UseGetNeeded(yO1){yW1>=0&&value<c1)return--tY1[eW2
+eO
+0;}
+}
+;yD
+size_t
+y9
+long
+count
+cC1
+y0&eR,yM1;x73
+yP1
+size_t
+apos,long
+aval,size_t
+bpos,long
+bval
+cC1
+unsigned
+cumulation_opcode,unsigned
+cimulation_opcode_flip,yM1;void
+l31
+yO1
+cC1
+int
+need_count,int
+iZ=0){yW1<1)return;
+#ifdef FP_GENERATING_POWI_TABLE
+if(iZ>32)throw
+false;
+#endif
+if(iC.Plan_Add(value,need_count
+tJ2;long
+xH3
+1;yW1<POWI_TABLE_SIZE){xH3
+powi_table[eW2
+n73&128
+xA2
+if(xI3
+xH3-eX2
+FPO(t03(t43,"value=%ld, half=%ld, otherhalf=%ld\n",value,half,value/half));l31
+half,c02
+iC.iU2
+half)eO;}
+i81
+xI3{xH3-eX2}
+}
+else
+yW1&1)xH3
+value&((1<<POWI_WINDOW_SIZE)-1);else
+xH3
+value/2;long
+cO=value-half
+n73>cO||half<0)std::swap(half,cO);FPO(t03(t43,"value=%ld, half=%ld, otherhalf=%ld\n",value,half,otherhalf))n73==cO){l31
+half,iC,2,iZ+1);}
+else{l31
+half,c02
+l31
+cO>0?cO:-cO,c02}
+iC.iU2
+value);}
+yD
+size_t
+y9
+yO1
+cC1
+y0&eR,yM1{int
+xJ3=iC.Find(value);if(xJ3>=0)yS
+xJ3;}
+long
+xH3
+1;yW1<POWI_TABLE_SIZE){xH3
+powi_table[eW2
+n73&128
+xA2
+if(xI3
+xH3-eX2
+FPO(t03(t43,"* I want %ld, my plan is %ld * %ld\n",value,half,value/half));size_t
+xB2=y9
+half
+e41
+if(iC
+n62
+half)>0||xB2!=e51){tZ1
+xB2)xE2
+half,e51);}
+nQ1
+value/half
+n32
+size_t
+tD3=e51
+xE2
+value,tD3);iC.DumpContents()eO
+tD3;}
+i81
+xI3{xH3-eX2}
+}
+else
+yW1&1)xH3
+value&((1<<POWI_WINDOW_SIZE)-1);else
+xH3
+value/2;long
+cO=value-half
+n73>cO||half<0)std::swap(half,cO);FPO(t03(t43,"* I want %ld, my plan is %ld + %ld\n",value,half,value-half))n73==cO){size_t
+xB2=y9
+half
+e41
+yP1
+xB2,half,xB2,half,iC,eR.op_normal,eR.op_normal_flip,synth);}
+else{long
+part1=half;long
+part2=cO>0?cO:-cO;size_t
+part1_pos=y9
+part1
+e41
+size_t
+part2_pos=y9
+part2
+e41
+FPO(t03(t43,"Subdivide(%ld: %ld, %ld)\n",value,half,otherhalf));yP1
+part1_pos,part1,part2_pos,part2,iC,cO>0?eR.op_normal:eR.op_inverse,cO>0?eR.op_normal_flip:eR.op_inverse_flip,synth);}
+size_t
+tD3=e51
+xE2
+value,tD3);iC.DumpContents()eO
+tD3;}
+x73
+yP1
+size_t
+apos,long
+aval,size_t
+bpos,long
+bval
+cC1
+unsigned
+cumulation_opcode,unsigned
+cumulation_opcode_flip,yM1{int
+a_needed=iC
+n62
+aval);int
+xK3=iC
+n62
+bval);bool
+flipped
+e23
+#define DUP_BOTH() do{if(apos<bpos){size_t tmp=apos;apos=bpos;bpos=tmp e81 FPO(t03(t43,"-> " tB3 tB3"op\n",(unsigned)apos,(unsigned)bpos));tZ1 apos);tZ1 apos==bpos?e51:bpos);}while(0)
+#define DUP_ONE(p) do{FPO(t03(t43,"-> " tB3"op\n",(unsigned)p));tZ1 p);}while(0)
+if(a_needed>0
+cI3
+xK3>0){lV2}
+eN3
+bpos!=e51)lV2
+else{nF2
+e81}
+}
+i81
+xK3>0
+cI3
+apos!=e51)lV2
+else
+DUP_ONE(bpos);}
+eN3
+apos==bpos&&apos==e51)nF2;i81
+apos==e51&&bpos==synth.xH
+2){FPO(t03(t43,"-> op\n"))e81
+i81
+apos==synth.xH
+2&&bpos==e51)FPO(t03(t43,"-> op\n"));i81
+apos==e51)DUP_ONE(bpos);i81
+bpos==e51){nF2
+e81
+else
+lV2}
+n42
+flipped?cumulation_opcode_flip:cumulation_opcode,2);}
+x73
+yX1
+long
+count,y0&eR,yM1{while(count<256){int
+xH3
+x51::powi_table[count]n73&128
+xA2
+yX1
+half
+n32
+count/=half;}
+else
+yY3
+if(count==1)return;if(!(count&1)){n42
+cSqr,1);yX1
+count/2
+n32}
+else{tZ1
+e51);yX1
+count-1
+n32
+n42
+cMul,2);}
+}
+}
+iR2
+x51{x73
+nQ1
+long
+count,y0&eR,yM1{if(count==0)eV1
+eR.basevalue);else{bool
+eY2
+e23
+if(count<0){eY2=true;count=-count;}
+if(false)yX1
+count
+n32
+i81
+count>1){PowiCache
+iC;l31
+count,iC,1);size_t
+x91
+eJ3
+GetStackTop();iC.Start(e51);FPO(t03(t43,"Calculating result for %ld...\n",count));size_t
+xC2=y9
+count
+e41
+size_t
+n_excess
+eJ3
+xH
+x91;if(n_excess>0||xC2!=x91-1){synth.DoPopNMov(x91-1,xC2);}
+}
+if(eY2)n42
+eR.op_flip,1);}
+}
+}
+#endif
+#ifndef FPOptimizer_ValueRangeHH
+#define FPOptimizer_ValueRangeHH
+tC{iR2
+iV2{iN
+cP2
+Comp{}
+;t91>cP2
+Comp<nE
+cLess>{t91
+lF<nC
+cLessOrEq>{t91
+lF<=nC
+cGreater>{t91
+lF>nC
+cGreaterOrEq>{t91
+lF>=nC
+cEqual>{t91
+lF==nC
+tP1>{t91
+lF!=b;}
+}
+;}
+yD
+cP2
+rangehalf{l62
+val;bool
+known;rangehalf():val(),known(false){}
+rangehalf
+cX1
+v):val(v),known(true){x61
+void
+set
+cX1
+v){known=true;val=v
+n63
+set(l62(i01(l62
+nP)val=i11
+void
+set(l62(i01
+cX1
+nP)val=i11
+iN
+void
+set_if(l62
+v,l62(i01(l62
+nP&&iV2::Comp<Compare>()(val,v))val=i11
+iN
+void
+set_if
+cX1
+v,l62(i01
+cX1
+nP&&iV2::Comp<Compare>()(val,v))val=i11}
+;yD
+cP2
+range{rangehalf
+yB
+min,max;range():min(),max(){}
+range(l62
+mi,l62
+ma):min(mi),max(ma){}
+range(bool,l62
+ma):min(),max(ma){}
+range(l62
+mi,bool):min(mi),max(){}
+void
+set_abs();void
+set_neg();}
+;yD
+bool
+IsLogicalTrueValue
+cY1
+range
+yB&p
+eZ2;yD
+bool
+IsLogicalFalseValue
+cY1
+range
+yB&p
+eZ2;}
+#endif
+#ifndef FPOptimizer_RangeEstimationHH
+#define FPOptimizer_RangeEstimationHH
+tC{enum
+TriTruthValue{IsAlways,xL3,Unknown}
+;yD
+range
+yB
+iO
+xB3);yD
+bool
+IsLogicalValue
+cY1
+cV2;yD
+TriTruthValue
+GetIntegerInfo
+cY1
+cV2;yD
+xA1
+GetEvennessInfo
+cY1
+cV2{if(!tree
+yP2
+tJ2
+Unknown;yB1=tree.xE1;if(nE
+isEvenInteger(value
+tJ2
+IsAlways;if(nE
+isOddInteger(value
+tJ2
+xL3
+xD2
+yD
+xA1
+GetPositivityInfo
+cY1
+cV2{range
+yB
+p=iO
+tree);if(p
+eY
+cF3>=l62(tJ2
+IsAlways;if(p
+t6
+yG1
+tJ2
+xL3
+xD2
+yD
+xA1
+GetLogicalValue
+iX2
+tree
+eZ2{range
+yB
+p=iO
+tree);if(IsLogicalTrueValue(p,abs
+tJ2
+IsAlways;if(IsLogicalFalseValue(p,abs
+tJ2
+xL3
+xD2}
+#endif
+#ifndef FPOptimizer_ConstantFoldingHH
+#define FPOptimizer_ConstantFoldingHH
+tC{x73
+ConstantFolding(cV2;}
+#endif
+iR2{using
+iR2
+FUNCTIONPARSERTYPES;using
+tC;cP2
+ComparisonSetBase{enum{cX3=0x1,Eq_Mask=0x2,Le_Mask=0x3,cY3=0x4,cZ3=0x5,Ge_Mask=0x6}
+;static
+int
+Swap_Mask(int
+m)yS(m&Eq_Mask)|((m&cX3)?cY3:0)|((m&cY3)?cX3:0);}
+enum
+yQ1{Ok,BecomeZero,BecomeOne,n21
+nO3
+nG2{cond_or,i92,iA2,iB2}
+;}
+;yD
+cP2
+ComparisonSet:public
+ComparisonSetBase{cP2
+t02{xG
+a;xG
+b;int
+relationship;t02():a(),b(),relationship(){}
+}
+e72
+t02>eB;cP2
+Item{xG
+value;bool
+c12;Item():value(),c12(false){}
+}
+e72
+Item>yY1;int
+xB1;ComparisonSet():eB(),yY1(),xB1(0){}
+yQ1
+AddItem
+iX2
+a,bool
+c12,nG2
+type){for
+x72
+c=0;c<yY1.size();++c)if(yY1[c].value
+xI
+a)cI3
+c12!=yY1[c].c12){iP
+cF1
+case
+iB2:yY1.erase(yY1.begin()+c);xB1
+c22
+case
+i92:case
+iA2:cG1}
+}
+return
+n21;}
+Item
+pole;pole.value=a;pole.c12=c12;yY1
+yS2
+pole)eO
+Ok;}
+yQ1
+AddRelationship(xG
+a,xG
+b,int
+tI1,nG2
+type){iP
+if(tI1==7)cF1
+lD
+iB2:if(tI1==7){xB1
+c22}
+lD
+i92:case
+iA2:if(tI1==0)cG1
+yY3
+if(!(a.GetHash()<b.GetHash())){a.swap(b);tI1=Swap_Mask(tI1);}
+for
+x72
+c=0;c<eB.size();++c
+cI3
+eB[c].a
+xI
+a)&&eB[c].b
+xI
+b)){iP{int
+xM3=yQ2|tI1;if(xM3==7)cF1
+yQ2=xM3;break
+cT1
+i92:case
+iA2:{int
+xM3=yQ2&tI1;if(xM3==0)cG1
+yQ2=xM3;break
+cT1
+iB2:{int
+newrel_or=yQ2|tI1;int
+xF2=yQ2&tI1;iW1
+5&&xF2==0){yQ2=cZ3
+eO
+n21;}
+iW1
+7&&xF2==0){xB1+=1;eB.erase(eB.begin()+c)eO
+n21;}
+iW1
+7&&xF2==Eq_Mask){yQ2=Eq_Mask;xB1
+c22}
+y41}
+}
+return
+n21;}
+}
+t02
+comp;comp.a=a;comp.b=b;comp.relationship=tI1;eB
+yS2
+comp)eO
+Ok;}
+}
+;nH1
+l62,typename
+CondType>bool
+ConstantFolding_LogicCommon(xG&tree,CondType
+x11,bool
+xG2){bool
+should_regenerate
+e23
+ComparisonSet
+yB
+comp;for
+c6
+typename
+yC
+yQ1
+cB3=yC
+Ok;iT1
+atree=xP1
+a);switch(atree
+nF
+e53
+cEqual
+lH
+Eq_Mask,x11);lD
+tP1
+lH
+cZ3,x11);lD
+cLess
+lH
+cX3,x11);lD
+cLessOrEq
+lH
+Le_Mask,x11);lD
+cGreater
+lH
+cY3,x11);lD
+cGreaterOrEq
+lH
+Ge_Mask,x11);lD
+cNot:cB3
+e31
+l8
+0),true,x11);lD
+cNotNot:cB3
+e31
+l8
+0),false,x11
+eP3;y13
+if(xG2||IsLogicalValue(atree))cB3
+e31,false,x11);yX3(cB3){ReplaceTreeWithZero
+e93.ReplaceWithImmed(0)eO
+true;ReplaceTreeWithOne
+e93.ReplaceWithImmed(1);x0
+yC
+Ok:lD
+yC
+BecomeZero
+tE
+yC
+BecomeOne:iA
+yC
+n21:yT1
+yN3
+if(should_regenerate){
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Before ConstantFolding_LogicCommon: "
+xY
+#endif
+if(xG2){tree.DelParams();}
+else{for
+c7{iT1
+atree=xP1
+a);if(IsLogicalValue(atree))e61);}
+}
+n72
+0;a<comp.yY1.size();++a
+cI3
+comp.yY1[a].c12
+iW2
+cNot);r
+i8
+r.nU1
+i81!xG2
+iW2
+cNotNot);r
+i8
+r.nU1
+else
+tree
+i8}
+n72
+0;a<comp.eB.size();++a
+iW2
+cNop);switch(comp.eB[a
+i1
+e53
+yC
+cX3:r
+c4
+cLess);lD
+yC
+Eq_Mask:r
+c4
+cEqual);lD
+yC
+cY3:r
+c4
+cGreater);lD
+yC
+Le_Mask:r
+c4
+cLessOrEq);lD
+yC
+cZ3:r
+c4
+tP1);lD
+yC
+Ge_Mask:r
+c4
+cGreaterOrEq);yY3
+r
+y7
+comp.eB[a].a);r
+y7
+comp.eB[a].b);r.nU1
+if(comp.xB1!=0)tree.yJ
+l62(comp.xB1)));
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"After ConstantFolding_LogicCommon: "
+xY
+#endif
+return
+true
+yC3
+e83
+yD
+bool
+ConstantFolding_AndLogic(t53(tree
+tC3()==cAnd||tree
+tC3()==cAbsAnd)eO
+nJ
+i92,true
+nD3
+ConstantFolding_OrLogic(t53(tree
+tC3()==cOr||tree
+tC3()==cAbsOr)eO
+nJ
+cond_or,true
+nD3
+ConstantFolding_AddLogicItems(t53(tree
+tC3()==cAdd)eO
+nJ
+iB2,false
+nD3
+ConstantFolding_MulLogicItems(t53(tree
+tC3()==cMul)eO
+nJ
+iA2,false);}
+}
+#include <vector>
+#include <map>
+#include <algorithm>
+iR2{using
+iR2
+FUNCTIONPARSERTYPES;using
+tC;cP2
+CollectionSetBase{enum
+xC1{Ok,n21}
+;}
+;yD
+cP2
+CollectionSet:public
+CollectionSetBase{cP2
+yR1{xG
+value;xG
+xH2;bool
+e4;yR1():value(),xH2(),e4(false){}
+yR1
+iX2
+v,iT1
+f):value(v),xH2(f),e4(false){}
+}
+;std::multimap<fphash_t,yR1>iD
+tO3
+typename
+std::multimap<fphash_t,yR1>::xR3
+xD1;CollectionSet():iD(){}
+xD1
+FindIdenticalValueTo
+iX2
+value){fphash_t
+hash=value.GetHash();for(xD1
+i=iD.xI2
+hash);i!=iD.cH1
+hash;++i){yW1
+xI
+i
+cW2.value
+tJ2
+i
+yC3
+iD.end();}
+bool
+Found
+cY1
+xD1&b)yS
+b!=iD.end();}
+xC1
+AddCollectionTo
+iX2
+xH2,const
+xD1&into_which){yR1&c=into_which
+cW2;if(c.e4)c.xH2
+cM
+xH2);else{xG
+add;add
+c4
+cAdd);add
+y7
+c.xH2);add
+cM
+xH2);c.xH2.swap(add);c.e4=true
+yC3
+n21;}
+xC1
+nH2
+iX2
+value,iT1
+xH2){const
+fphash_t
+hash=value.GetHash();xD1
+i=iD.xI2
+hash);for(;i!=iD.cH1
+hash;++i
+cI3
+i
+cW2.value
+xI
+value
+tJ2
+AddCollectionTo(xH2,i);}
+iD.xN3,std::make_pair(hash,yR1(value,xH2)))eO
+Ok;}
+xC1
+nH2
+iX2
+a)yS
+nH2(a,n31
+1)));}
+}
+;yD
+cP2
+ConstantExponentCollection{typedef
+nX2
+xP3
+tO3
+std::nV1
+xJ2
+e72
+xJ2>data;ConstantExponentCollection():data(){}
+void
+MoveToSet_Unique
+cX1
+eF1&eG1){data
+yS2
+std::nV1(eF1()));data.back().second.swap(eG1
+n33
+MoveToSet_NonUnique
+cX1
+eF1&eG1){typename
+std::vector<xJ2>::xR3
+i=std::xI2
+data.iC2
+data.end(),nU3,Compare1st());if(i!=data.cH1
+x32{i
+cW2.xN3
+cW2.end(),eG1.iC2
+eG1.end());}
+else{data.xN3,std::nV1(nU3,eG1));}
+}
+bool
+i22{bool
+changed
+e23
+std::sort(data.iC2
+data.end(),Compare1st());redo:n72
+0;a<data.size();++a){l62
+exp_a=data[a
+e03;if(fp_equal(exp_a,l62(1)))y41
+x62
+a+1;b<data.size();++b){l62
+exp_b=data[b
+e03;l62
+xK2=exp_b-exp_a;if(xK2>=fp_abs(exp_a
+lE3
+exp_diff_still_probable_integer=xK2*l62(16);if(t12
+exp_diff_still_probable_integer)&&!(t12
+exp_b)&&!t12
+xK2))){xP3&a_set=iX1;xP3&b_set=data[b].second;
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Before ConstantExponentCollection iteration:\n"
+;t22
+cout);
+#endif
+if(isEvenInteger(exp_b)&&!isEvenInteger(xK2+exp_a)nQ
+tmp2;tmp2
+c4
+cMul);tmp2
+iY1
+b_set);tmp2
+eM1
+t21
+cAbs);tmp
+c43;tmp
+eM1
+b_set
+x53
+1);b_set[0].tV2}
+a_set.insert(a_set.end(),b_set.iC2
+b_set.end());xP3
+b_copy=b_set;data.erase(data.begin()+b);MoveToSet_NonUnique(xK2,b_copy);nS2
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"After ConstantExponentCollection iteration:\n"
+;t22
+cout);
+#endif
+cN}
+}
+}
+return
+changed;}
+#ifdef DEBUG_SUBSTITUTIONS
+void
+t22
+ostream&out){n72
+0;a<data.size();++a){out.precision(12);out<<data[a
+e03<<": "
+;xS3
+iX1.size();++b
+cI3
+b>0)out<<'*'
+yR2
+iX1[b],out);}
+out<<std::endl;}
+}
+#endif
+}
+;yD
+static
+xG
+nW1
+xG&value,bool&xL){switch(value
+nF
+e53
+cPow:{xG
+cY2
+value
+l8
+1);value.y31
+eO
+nU3
+cT1
+cRSqrt:value.y31;xL=true
+eO
+n31-0.5));case
+cInv:value.y31;xL=true
+eO
+n31-1));y13
+break
+yC3
+n31
+1));}
+yD
+static
+void
+eH1
+l12&mul,xB3,iT1
+xH2,bool&yS1
+bool&xL){n72
+0;a<t7;++a
+nQ
+value
+tN3);xG
+nU3(nW1
+value,xL));if(!xH2
+yP2)||xH2.xE1!=l62(1.0)nQ
+cI1;cI1
+c4
+cMul);cI1
+cM
+x32;cI1
+cM
+xH2);cI1
+eM1
+nU3.swap(cI1);}
+#if 0 /* FIXME: This does not work */
+yW1
+nF==cMul
+cI3
+1){bool
+exponent_is_even=nU3
+yP2)&&isEvenInteger(nU3.xE1);xS3
+value.x31++b){bool
+tmp
+e23
+xG
+val(value
+l8
+b));xG
+exp(nW1
+val,tmp));if(exponent_is_even||(exp
+yP2)&&isEvenInteger(exp.xE1))nQ
+cI1;cI1
+c4
+cMul);cI1
+cM
+x32;cI1
+y7
+exp);cI1.ConstantFolding();if(!cI1
+yP2)||!isEvenInteger(cI1.xE1)){goto
+cannot_adopt_mul;}
+}
+}
+}
+eH1
+mul,value,nU3,yS1
+xL);}
+else
+cannot_adopt_mul:
+#endif
+{if(mul.nH2(value,x32==CollectionSetBase::n21)yT1}
+}
+}
+yD
+bool
+ConstantFolding_MulGrouping(cV2{bool
+xL
+e23
+bool
+should_regenerate
+e23
+l12
+mul;eH1
+mul,tree,n31
+1)),yS1
+xL)tO3
+std::pair<xG,nX2>eI1
+tO3
+std::multimap<fphash_t,eI1>yZ1;yZ1
+iE;xL2
+l12::xD1
+j=mul.iD.xQ3
+j!=mul.iD.end();++j
+nQ&value=j
+cW2.value;xG&cY2
+j
+cW2.xH2;if(j
+cW2.e4)nU3
+eM1
+const
+fphash_t
+eJ1=nU3.GetHash();typename
+yZ1::xR3
+i=iE.xI2
+eJ1);for(;i!=iE.cH1
+eJ1;++i)if(i
+cW2.first
+xI
+x32
+cI3!nU3
+yP2)||!cJ1.xE1,l62(1)))yT1
+i
+cW2.second
+yS2
+value);goto
+skip_b;}
+iE.xN3,std::make_pair(eJ1,std::make_pair(nU3,nX2
+x72(1),value))));skip_b:;}
+#ifdef FP_MUL_COMBINE_EXPONENTS
+ConstantExponentCollection
+yB
+cK1;xL2
+yZ1::xR3
+j,i=iE.xQ3
+i!=iE.end();i=j){j=i;++j;eI1&list=i
+cW2;if(list
+y93
+lK1
+cY2
+list
+y93
+xE1;if(!(nU3==tD1)))cK1.MoveToSet_Unique(nU3,list.second);iE.erase(i);}
+}
+if(cK1.i22)yT1
+#endif
+if(should_regenerate
+nQ
+before=tree;before.l41
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Before ConstantFolding_MulGrouping: "
+yR2
+before)xO1"\n"
+;
+#endif
+tree.DelParams();xL2
+yZ1::xR3
+i=iE.xQ3
+i!=iE.end();++i){eI1&list=i
+cW2;
+#ifndef FP_MUL_COMBINE_EXPONENTS
+if(list
+y93
+lK1
+cY2
+list
+y93
+xE1;if(nU3==tD1))y41
+if(cJ1
+n53
+tree.AddParamsMove(list.second);y41}
+}
+#endif
+xG
+mul;mul
+c4
+cMul);mul
+iY1
+list.second);mul
+eM1
+if(xL&&list
+y93
+lO2
+list
+y93
+xE1==l62(1)/l62(3)nQ
+cbrt;cbrt
+c4
+cCbrt);cbrt
+xM2
+cbrt
+eM1
+tree
+y7
+cbrt);y41
+cP
+0.5)nQ
+sqrt;sqrt
+c4
+cSqrt);sqrt
+xM2
+sqrt
+eM1
+tree
+y7
+sqrt);y41
+cP-0.5)nQ
+rsqrt;rsqrt
+c4
+cRSqrt);rsqrt
+xM2
+rsqrt
+eM1
+tree
+y7
+rsqrt);y41
+cP-1)nQ
+inv;inv
+c4
+cInv);inv
+xM2
+inv
+eM1
+tree
+y7
+inv);y41}
+}
+xG
+pow;pow
+c4
+cPow);pow
+xM2
+pow
+y7
+list.first);pow
+eM1
+tree
+y7
+pow);}
+#ifdef FP_MUL_COMBINE_EXPONENTS
+iE.clear();n72
+0;a<i6.size();++a){l62
+cY2
+i6[a
+e03;if(cJ1
+n53
+tree.AddParamsMove(i6[a].second);y41}
+xG
+mul;mul
+c4
+cMul);mul
+iY1
+i6[a].second);mul
+eM1
+xG
+pow;pow
+c4
+cPow);pow
+xM2
+pow.yJ
+x32);pow
+eM1
+tree
+y7
+pow);}
+#endif
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"After ConstantFolding_MulGrouping: "
+xY
+#endif
+return!tree
+xI
+before)yC3
+e83
+yD
+bool
+ConstantFolding_AddGrouping(cV2{bool
+should_regenerate
+e23
+l12
+add;for
+c6
+if
+tN3
+nF==cMul)y41
+if(add.nH2
+tN3)==CollectionSetBase::n21)yT1}
+std::vector<bool>remaining(t7);size_t
+tJ=0;for
+c6
+iT1
+i82=xP1
+a);if(i82
+nF==cMul){xS3
+xY1
+x31++b
+cI3
+i82
+l8
+b)yP2))y41
+typename
+l12::xD1
+c=add.FindIdenticalValueTo(i82
+l8
+b));if(add.Found(c)nQ
+tmp(i82
+lL1
+CloneTag());tmp.DelParam(b);tmp
+eM1
+add.AddCollectionTo(tmp,c);yT1
+goto
+done_a;}
+}
+remaining[a]=true;tJ+=1;done_a:;}
+}
+if(tJ>0
+cI3
+tJ>1){std::vector<std::pair<xG,size_t> >nZ;std::multimap<fphash_t,size_t>eK1;bool
+iY2
+e23
+for
+eX{xS3
+xP1
+a).x31++b){iT1
+p=xP1
+a)l8
+b);const
+fphash_t
+p_hash=p.GetHash();for(std::multimap<fphash_t,size_t>::const_iterator
+i=eK1.xI2
+p_hash);i!=eK1.cH1
+p_hash;++i
+cI3
+nZ[i
+cW2
+e03
+xI
+p)){nZ[i
+cW2].second+=1;iY2=true;goto
+found_mulgroup_item_dup;}
+}
+nZ
+yS2
+std::make_pair(p,size_t(1)));eK1.insert(std::make_pair(p_hash,nZ.size()-1));found_mulgroup_item_dup:;}
+}
+if(iY2
+nQ
+cZ2;{size_t
+max=0;for
+x72
+p=0;p<nZ.size();++p)if(nZ[p].second<=1)nZ[p].second=0;else{nZ[p].second*=nZ[p]y93
+xT2;if(nZ[p].second>max){cZ2=nZ[p
+e03;max=nZ[p].second;}
+}
+}
+xG
+group_add;group_add
+c4
+cAdd);
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Duplicate across some trees: "
+yR2
+cZ2)xO1" in "
+xY
+#endif
+for
+eX
+xS3
+xP1
+a).x31++b)if(cZ2
+xI
+xP1
+a)l8
+b))nQ
+tmp
+tN3
+lL1
+CloneTag());tmp.DelParam(b);tmp
+eM1
+group_add
+y7
+tmp);remaining[a]e23
+yY3
+group_add
+eM1
+xG
+group;group
+c4
+cMul);group
+y7
+cZ2);group
+y7
+group_add);group
+eM1
+add.nH2(group);yT1}
+}
+for
+eX{if(add.nH2
+tN3)==CollectionSetBase::n21)yT1}
+}
+if(should_regenerate){
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Before ConstantFolding_AddGrouping: "
+xY
+#endif
+tree.DelParams();xL2
+l12::xD1
+j=add.iD.xQ3
+j!=add.iD.end();++j
+nQ&value=j
+cW2.value;xG&coeff=j
+cW2.xH2;if(j
+cW2.e4)coeff
+eM1
+if(coeff.lO2
+fp_equal(coeff.xE1,tD1)))y41
+if(fp_equal(coeff.xE1
+n53
+tree
+y7
+value);y41}
+}
+xG
+mul;mul
+c4
+cMul);mul
+y7
+value);mul
+y7
+coeff);mul
+eM1
+tree
+xM2}
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"After ConstantFolding_AddGrouping: "
+xY
+#endif
+return
+true
+yC3
+e83}
+iR2{using
+iR2
+FUNCTIONPARSERTYPES;using
+tC;yD
+bool
+ConstantFolding_IfOperations(t53(tree
+tC3()==cIf||tree
+tC3()==cAbsIf);for(;;cI3
+e43
+cNot){tree
+c4
+cIf);tQ
+iD2
+tQ
+xN2
+t32.swap(cC3);}
+i81
+tQ
+c71{tree
+c4
+e63;tQ
+iD2
+tQ
+xN2
+t32.swap(cC3);}
+else
+break;yX3
+nR1
+tQ,i21
+e63)i71
+tree
+iD2
+t32);x0
+iO2
+tree
+iD2
+cC3);x0
+lS1
+if(e43
+cIf||e43
+cAbsIf
+nQ
+cond=tQ;xG
+iZ2;iZ2
+c4
+cond
+nF==cIf?cNotNot:cAbsNotNot);iZ2
+xP2
+1));ConstantFolding(iZ2);xG
+l03;l03
+c4
+cond
+nF==cIf?cNotNot:cAbsNotNot);l03
+xP2
+2));ConstantFolding(l03);if(iZ2
+yP2)||l03
+yP2)nQ
+eS;eS
+c4
+cond
+nF);eS
+xP2
+1));eS.n7
+1));eS.n7
+2));eS
+eM1
+xG
+eT;eT
+c4
+cond
+nF);eT
+xP2
+2));eT.n7
+1));eT.n7
+2));eT
+eM1
+tree
+c4
+cond
+nF)y51
+0,cond
+xN2
+tree.n41
+1,eS);tree.n41
+2,eT)cT2}
+if(t32
+nF==cC3
+nF&&(t32
+nF==cIf||t32
+nF==e63
+nQ&i72=t32;xG&leaf2=cC3;if(i72
+l8
+0)x21
+0))&&(i72
+l8
+1)x21
+1))||i72
+l8
+2)x21
+2)))nQ
+eS;eS
+n82
+eS.n7
+0));eS
+cM
+i72
+l8
+1));eS
+cM
+leaf2
+l8
+1));eS
+eM1
+xG
+eT;eT
+n82
+eT.n7
+0));eT
+cM
+i72
+l8
+2));eT
+cM
+leaf2
+l8
+2));eT
+t5
+SetParam(0,i72
+xN2
+tree.n41
+1,eS);tree.n41
+2,eT)cT2
+if(i72
+l8
+1)x21
+1))&&i72
+l8
+2)x21
+2))nQ
+eU;eU
+n82
+eU
+y7
+tQ);eU
+cM
+i72
+xN2
+eU
+cM
+leaf2
+xN2
+eU
+t5
+n41
+0,eU)y51
+2,i72
+l8
+2))y51
+1,i72
+l8
+1))cT2
+if(i72
+l8
+1)x21
+2))&&i72
+l8
+2)x21
+1))nQ
+e02;e02
+c4
+leaf2
+nF==cIf?cNot:c03);e02
+cM
+leaf2
+xN2
+e02
+eM1
+xG
+eU;eU
+n82
+eU
+y7
+tQ);eU
+cM
+i72
+xN2
+eU
+y7
+e02);eU
+t5
+n41
+0,eU)y51
+2,i72
+l8
+2))y51
+1,i72
+l8
+1))cT2}
+xG&y2=t32;xG&y6=cC3;if(y2
+xI
+y6)){tree
+iD2
+t32)cT2
+const
+OPCODE
+op1=y2
+nF;const
+OPCODE
+op2=y6
+nF;cL3
+op2
+cI3
+y2
+yU1
+1
+nQ
+lP
+0));xQ2
+0))iZ1
+n4
+if(y2
+yU1
+2&&y6
+yU1
+2
+cI3
+y2
+l8
+0)xI
+y6
+l8
+0))nQ
+param0=y2
+l8
+0);xG
+lP
+1));xQ2
+1))iZ1
+e12
+param0)n4
+if(y2
+l8
+1)xI
+y6
+l8
+1))nQ
+param1=y2
+l8
+1);xG
+lP
+0));xQ2
+0))iZ1
+e12
+n11)e12
+param1)cT2}
+cL3
+xT3
+cMul
+l02
+cAnd
+l02
+cOr
+l02
+cAbsAnd
+l02
+cAbsOr
+l02
+cMin
+l02
+cMax){nX2
+l13;c3{x62
+y6.x31
+b-->0;){nI2
+y6
+l8
+b))cI3
+l13
+yU3){y2.e73
+l41}
+l13
+yS2
+y2
+lS3
+y6.DelParam(b);y2.DelParam(a);yN3}
+if(!l13
+yU3){y2.Rehash(eL1
+n11;n11
+n82
+n11
+iY1
+tree.iP1))yF
+SetParamsMove(l13)n4}
+}
+cL3
+xT3
+cMul||(op1==cAnd
+nK1
+y6))||(op1==cOr
+nK1
+y6))){c3
+nI2
+y6)){y2.l41
+y2.DelParam(a);y2
+eM1
+xG
+c01=y6;y6=tK
+op1==xT3
+cOr)l9
+op1)e12
+c01)n4}
+if((op1==cAnd
+l02
+cOr)&&op2==cNotNot
+nQ&l23=y6
+l8
+0);c3
+nI2
+l23)){y2.l41
+y2.DelParam(a);y2
+eM1
+xG
+c01=l23;y6=tK
+op1
+xU3
+op1)e12
+c01)n4}
+if(op2==cAdd||op2==cMul||(op2==cAnd
+nK1
+y2))||(op2==cOr
+nK1
+y2))){n72
+y6.n93
+y6
+l8
+a)xI
+y2)){y6.e73
+DelParam(a
+eL1
+c11=y2;y2=tK
+op2==cAdd||op2
+xU3
+op2)e12
+c11)n4}
+if((op2==cAnd||op2==cOr)&&op1==cNotNot
+nQ&l33=y2
+l8
+0);n72
+y6.n93
+y6
+l8
+a)xI
+l33)){y6.e73
+DelParam(a
+eL1
+c11=l33;y2=tK
+op2
+xU3
+op2)e12
+c11)n4}
+return
+e83}
+#include <limits>
+iR2{using
+iR2
+FUNCTIONPARSERTYPES;using
+tC;yD
+int
+maxFPExponent()yS
+std::numeric_limits
+yB::max_exponent;}
+yD
+bool
+tE1
+l62
+base,l62
+x32{if(base<tD1
+t41;if(fp_equal(base,tD1))||fp_equal(base,l62(1))c5
+return
+nU3>=l62(maxFPExponent
+yB())/fp_log2(base);}
+yD
+int
+nY1
+l62
+val){int
+ex=0;l62
+t=std::frexp(val,&ex);unsigned
+yO1=fp_abs(t)*(1u<<30),v0=value;unsigned
+int
+nT3=0;while(!(value&1))value>>=1;for(;value!=0;value>>=1)++nT3
+eO
+nT3;}
+yD
+bool
+ConstantFolding_PowOperations(t53(tree
+tC3()==cPow);cD3
+t32.lK1
+const_value
+xV3
+lS,tM));tree.ReplaceWithImmed(const_value)eO
+e83
+if
+lM1
+fp_equal(tM)n53
+tree
+iD2
+tQ)cT2
+cD3
+fp_equal(lS,l62(1)nR
+1)eO
+e83
+cD3
+t32
+nF==cMul){bool
+xR2
+e23
+l62
+eO1=lS;xG
+i82=t32;n72
+xY1
+n93
+i82
+l8
+a).lK1
+imm=i82
+l8
+a).xE1;{if(tE1
+eO1,imm
+lE3
+c21
+xV3
+eO1,imm);if(fp_equal(c21,tD1)))break;if(nY1
+c21)<(nY1
+eO1)+nY1
+imm))/4){yY3
+if(!xR2){xR2=true;xY1
+l41}
+eO1=c21;xY1
+DelParam(a);yN3
+if(xR2){xY1
+Rehash();
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Before pow-mul change: "
+xY
+#endif
+tQ
+iD2
+cL1
+eO1));t32
+iD2
+i82);
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"After pow-mul change: "
+xY
+#endif
+}
+}
+if
+lM1
+e43
+cMul){l62
+l72=tM);l62
+xS2=1.0;bool
+xR2
+e23
+xG&i82=tQ;n72
+xY1
+n93
+i82
+l8
+a).lK1
+imm=i82
+l8
+a).xE1;{if(tE1
+imm,l72
+lE3
+eP1
+xV3
+imm,l72);if(fp_equal(eP1,tD1)))break;if(!xR2){xR2=true;xY1
+l41}
+xS2*=eP1;xY1
+DelParam(a);yN3
+if(xR2){xY1
+Rehash();xG
+cH3;cH3
+c4
+cPow);cH3
+iY1
+tree.iP1));cH3.lF2
+tree
+c4
+cMul)e12
+cH3);tree
+cM
+cL1
+xS2))cT2}
+if(e43
+cPow&&xP1
+yO2&&tQ
+l8
+1).lK1
+a=tQ
+l8
+1).xE1;l62
+b=tM);l62
+c=a*b;if(isEvenInteger(a)&&!isEvenInteger(c)nQ
+l43;l43
+c4
+cAbs);l43.n7
+0)xN2
+l43
+eM1
+tree.n41
+0,l43);}
+else
+tree.SetParam(0,tQ
+l8
+0))y51
+1,cL1
+c))yC3
+e83}
+iR2{using
+iR2
+FUNCTIONPARSERTYPES;using
+tC;cP2
+l4{enum
+e22{MakeFalse=0,MakeTrue=1,t42=2,l73=3,MakeNotNotP0=4,MakeNotNotP1=5,MakeNotP0=6,MakeNotP1=7,xK=8
+nO3
+l82{Never=0,Eq0=1,Eq1=2,xW3=3,xX3=4}
+;e22
+if_identical;e22
+l92
+4];cP2{e22
+what:4;l82
+when:4;}
+iA1,iB1,iC1,iD1;yD
+e22
+Analyze
+iX2
+a,iT1
+b)const{if(a
+xI
+b
+tJ2
+if_identical;range
+yB
+p0=iO
+a);range
+yB
+p1=iO
+b);if(p0
+t6&&p1
+eY
+cI3
+p0
+nV<p1
+e32&&l92
+0]i7
+0];if(p0
+nV<=p1
+e32&&l92
+1]i7
+1];}
+if(p0
+eY&&p1
+t6
+cI3
+p0
+e32>p1
+nV&&l92
+2]i7
+2];if(p0
+e32>=p1
+nV&&l92
+3]i7
+3];}
+if(IsLogicalValue(a)cI3
+iA1
+e92
+iA1.when,p1
+tJ2
+iA1.what;if(iC1
+e92
+iC1.when,p1
+tJ2
+iC1.what;}
+if(IsLogicalValue(b)cI3
+iB1
+e92
+iB1.when,p0
+tJ2
+iB1.what;if(iD1
+e92
+iD1.when,p0
+tJ2
+iD1.what
+yC3
+xK;}
+yD
+static
+bool
+TestCase(l82
+when,const
+range
+yB&p
+cI3!p
+eY||!p
+t6
+c5
+switch(when
+e53
+Eq0
+nM1==l62(0.0
+eB3==p
+e32;case
+Eq1
+nM1==l62(1.0
+eB3==p
+nV;case
+xW3
+nM1>tD1
+eB3<=l62(1);case
+xX3
+nM1
+cW1
+yG1
+1);y13
+yC3
+e83}
+;iR2
+RangeComparisonsData{static
+const
+l4
+Data[6]={{l4
+l53
+i2
+xK,l4::i2
+xK}
+,n71
+Eq1}
+,n81
+Eq1}
+,{l4::c31
+Eq0}
+,{l4::c41
+Eq0}
+}
+,{l4::nJ2
+l63
+xK,l4
+l63
+xK}
+,n71
+Eq0}
+,n81
+Eq0}
+,{l4::c31
+Eq1}
+,{l4::c41
+Eq1}
+}
+,{l4::nJ2
+l63
+t42,l4::i2
+MakeFalse}
+,{l4::c31
+xW3}
+,n81
+xX3
+yZ,{l4
+l53
+xK,l4
+l63
+i2
+l73}
+,{l4::c31
+xX3}
+,n81
+xW3
+yZ,{l4::nJ2::i2
+i2
+MakeTrue,l4::t42}
+,n71
+xX3}
+,{l4::c41
+xW3
+yZ,{l4
+l53
+i2
+l73,l4::xK,l4
+n61}
+,n71
+xW3}
+,{l4::c41
+xX3
+yZ}
+;}
+yD
+bool
+ConstantFolding_Comparison(cV2{using
+iR2
+RangeComparisonsData;assert(tree tC3()>=cEqual&&tree tC3()<=cGreaterOrEq);switch(Data[tree
+nF-cEqual].Analyze(tQ,t32)e53
+l4::MakeFalse
+e93.ReplaceWithImmed(0);x0
+l4
+n61
+e93.ReplaceWithImmed(1
+l52
+l73
+e93
+c4
+cEqual
+l52
+t42
+e93
+c4
+tP1
+l52
+MakeNotNotP0
+e93
+c4
+cNotNot)lP2
+1
+l52
+MakeNotNotP1
+e93
+c4
+cNotNot)lP2
+0
+l52
+MakeNotP0
+e93
+c4
+cNot)lP2
+1
+l52
+MakeNotP1
+e93
+c4
+cNot)lP2
+0
+l52
+xK:;}
+if(xP1
+yO2)switch(tQ
+nF
+e53
+cAsin:lN
+fp_sin
+xY3
+cAcos:lN
+fp_cos
+tL));tree
+c4
+i21
+cLess?cGreater:i21
+cLessOrEq?cGreaterOrEq:i21
+cGreater?cLess:i21
+cGreaterOrEq?cLessOrEq
+e93
+nF);x0
+cAtan:lN
+fp_tan
+xY3
+cLog:lN
+fp_exp
+xY3
+cSinh:lN
+fp_asinh
+xY3
+cTanh:if(fp_less(fp_abs
+tL
+n53
+lN
+fp_atanh
+tL))cT2
+break;y13
+break
+yC3
+e83}
+#include <list>
+#include <algorithm>
+#ifdef FP_SUPPORT_OPTIMIZER
+using
+iR2
+FUNCTIONPARSERTYPES;iR2{
+#ifdef DEBUG_SUBSTITUTIONS
+yM
+double
+d){union{double
+d;uint_least64_t
+h;}
+t52
+d=d;lG1
+h
+nN1
+#ifdef FP_SUPPORT_FLOAT_TYPE
+yM
+float
+f){union{float
+f;uint_least32_t
+h;}
+t52
+f=f;lG1
+h
+nN1
+#endif
+#ifdef FP_SUPPORT_LONG_DOUBLE_TYPE
+yM
+long
+double
+ld){union{long
+double
+ld;cP2{uint_least64_t
+a;unsigned
+short
+b;}
+s;}
+t52
+ld=ld;lG1
+s.b<<data.s.a
+nN1
+#endif
+#ifdef FP_SUPPORT_LONG_INT_TYPE
+yM
+long
+ld){o<<"("
+<<std::hex<<ld
+nN1
+#endif
+#endif
+}
+tC{lO
+nG)){}
+lO
+const
+l62&i
+lL1
+x23
+nG
+i)){data
+xE
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
+lO
+l62&&i
+lL1
+x23
+nG
+std::move(i))){data
+xE
+#endif
+lO
+unsigned
+v
+lL1
+VarTag
+nG
+iE2,v))c32
+nW2
+o
+lL1
+OpcodeTag
+nG
+o))c32
+nW2
+o,unsigned
+f
+lL1
+FuncOpcodeTag
+nG
+o,f))c32
+iT1
+b
+lL1
+CloneTag
+nG*b.data)){}
+yD
+xG::~CodeTree(){}
+lC
+ReplaceWithImmed
+cX1
+i){
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Replacing "
+yR2*this);if(IsImmed())OutFloatHex(std::cout,xE1)xO1" with const value "
+<<i;OutFloatHex(std::cout,i)xO1"\n"
+;
+#endif
+data=new
+x42
+yB(i);}
+yD
+cP2
+ParamComparer{bool
+eD1()iX2
+a,iT1
+b)const{if(a.xT2!=b.xT2)return
+a.xT2<b.xT2
+eO
+a.GetHash()<b.GetHash();}
+}
+;x73
+x42
+yB::Sort(){switch(Opcode
+e53
+cAdd:case
+cMul:case
+cMin:case
+cMax:case
+cAnd:case
+cAbsAnd:case
+cOr:case
+cAbsOr:case
+cHypot:case
+cEqual:case
+tP1:std::sort(x83
+iC2
+x83
+end(),ParamComparer
+yB());lD
+cLess
+lZ
+cGreater;}
+lD
+cLessOrEq
+lZ
+cGreaterOrEq;}
+lD
+cGreater
+lZ
+cLess;}
+lD
+cGreaterOrEq
+lZ
+cLessOrEq;}
+break;y13
+yN3
+lC
+AddParam
+iX2
+param){y3
+yS2
+param);}
+lC
+eE
+xG&param){y3
+yS2
+xG());y3.back().swap(param);}
+lC
+SetParam
+x72
+which,iT1
+b)nO1
+which
+xZ3
+y3[which]=b;}
+lC
+n41
+size_t
+which,xG&b)nO1
+which
+xZ3
+y3[which
+eO3
+b);}
+lC
+AddParams
+cY1
+nK){y3.insert(y3.end(),lA2.iC2
+lA2.end());}
+lC
+AddParamsMove(nK){size_t
+endpos=y3.size(),added=lA2.size();y3
+x53
+endpos+added,xG());for
+x72
+p=0;p<added;++p)y3[endpos+p
+eO3
+lA2[p]);}
+lC
+AddParamsMove(nK,size_t
+lB2)nO1
+lB2
+xZ3
+DelParam(lB2);AddParamsMove(t81}
+lC
+SetParams
+cY1
+nK){nX2
+tmp(t81
+y3.tV2}
+lC
+SetParamsMove(nK){y3.swap(t81
+lA2.clear();}
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
+lC
+SetParams(nX2&&lA2){SetParamsMove(t81}
+#endif
+lC
+DelParam
+x72
+index){nX2&Params=y3;
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
+x83
+erase(x83
+begin()+index);
+#else
+Params[index].data=0;for
+x72
+p=index;p+1<y03;++p)Params[p].data.UnsafeSetP(Params[p+1]t62));Params[y03-1].data.UnsafeSetP(0);Params
+x53
+y03-1);
+#endif
+}
+lC
+DelParams(){y3.clear(nD3
+xG::IsIdenticalTo
+iX2
+b)const{if(data.get()==b
+t62
+t41
+eO
+data->IsIdenticalTo(*b.data
+nD3
+x42
+yB::IsIdenticalTo
+cY1
+x42
+yB&b)const{if(Hash!=b.Hash
+c5
+if(Opcode!=eL3
+c5
+switch(Opcode
+e53
+cImmed:return
+fp_equal(Value,eM3;case
+iE2:return
+iR1==b.iQ1
+case
+cFCall:case
+cPCall:if(iR1!=b.iR1
+c5
+break;y13
+yY3
+if(y03!=b.y03
+c5
+n72
+0;a<y03;++a
+cI3!x93
+xI
+b.x93)c5}
+return
+true;}
+lC
+Become
+iX2
+b
+cI3&b!=this&&data.get()!=b
+t62)){DataP
+tmp=b.data;l41
+data.tV2}
+}
+lC
+CopyOnWrite(cI3
+GetRefCount()>1)data=new
+x42
+yB(*data);}
+yD
+xG
+xG::GetUniqueRef(cI3
+GetRefCount()>1)return
+xG(*this,CloneTag())eO*this;}
+yD
+nO):yU
+cNop),Value(),n9
+yD
+nO
+const
+x42&b):yU
+eL3),Value(eM3,iR1(b.c51,Params(b.Params),Hash(b.Hash),Depth(b.Depth),tJ1
+b.iS1){}
+yD
+nO
+const
+l62&i):yU
+cImmed),Value(i),n9
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
+yD
+nO
+x42
+yB&&b):yU
+eL3),Value
+cX2
+eM3),iR1(b.c51,Params
+cX2
+b.Params)),Hash(b.Hash),Depth(b.Depth),tJ1
+b.iS1){}
+yD
+nO
+l62&&i):yU
+cImmed),Value
+cX2
+i)),n9
+#endif
+yD
+nO
+nW2
+o):yU
+o),Value(),n9
+yD
+nO
+nW2
+o,unsigned
+f):yU
+o),Value(),iR1(f),Params(),Hash(),Depth(1),tJ1
+0){}
+}
+#endif
+#ifdef FP_SUPPORT_OPTIMIZER
+#include <sstream>
+#include <string>
+#include <map>
+#include <set>
+#include <iostream>
+using
+iR2
+FUNCTIONPARSERTYPES;
+#ifdef FUNCTIONPARSER_SUPPORT_DEBUGGING
+iR2{x73
+tK1
+nU,std
+cF&done,std::ostream&o){n72
+0
+tH2
+tK1
+tJ3
+done,o);std::ostringstream
+buf
+yR2
+tree,buf);done[xC3].insert(buf.str());}
+}
+#endif
+tC{
+#ifdef FUNCTIONPARSER_SUPPORT_DEBUGGING
+x73
+DumpHashes(i9){std
+cF
+done;tK1
+tree,done,o);for(std
+cF::const_iterator
+i=done.xQ3
+i!=done.end();++i){const
+std::set<std
+yE3>&flist=i
+cW2;if(flist.size()!=1)o<<"ERROR - HASH COLLISION?\n"
+;for(std::set<std
+yE3>::const_iterator
+j=flist.xQ3
+j!=flist.end();++j){o<<'['<<std::hex<<i->first.hash1<<','<<i->first.hash2<<']'<<std::dec;o<<": "
+<<*j<<"\n"
+;}
+}
+}
+x73
+DumpTree(i9){nA3
+t33;switch
+l83{case
+cImmed:o<<tree.xE1
+eA3
+iE2:o<<"Var"
+<<(tree.GetVar()-iE2)eA3
+cAdd:t33"+"
+;lD
+cMul:t33"*"
+;lD
+cAnd:t33"&"
+;lD
+cOr:t33"|"
+;lD
+cPow:t33"^"
+;break;y13
+t33;o<<eK3
+l83;if(i21
+cFCall||i21
+cPCall)o<<':'<<tree.GetFuncNo();}
+o<<'(';if(t7<=1&&sep2[1])o<<(sep2+1)<<' ';for
+c6
+if(a>0)o<<' '
+yR2
+tJ3
+o);if(a+1<t7)o<<sep2;}
+o<<')';}
+x73
+DumpTreeWithIndent(i9,const
+std
+yE3&indent){o<<'['<<std::hex<<(void*)(&tree.iP1))<<std::dec<<','<<tree.GetRefCount()<<']';o<<indent<<'_';switch
+l83{case
+cImmed:o<<"cImmed "
+<<tree.xE1;o<<'\n'
+eA3
+iE2:o<<"VarBegin "
+<<(tree.GetVar()-iE2);o<<'\n'
+eO;y13
+o<<eK3
+l83;if(i21
+cFCall||i21
+cPCall)o<<':'<<tree.GetFuncNo();o<<'\n';}
+for
+c6
+std
+yE3
+ind=indent;for
+x72
+p=0;p<ind.size();p+=2)if(ind[p]=='\\')ind[p]=' ';ind+=(a+1<t7)?" |"
+:" \\"
+;DumpTreeWithIndent(tJ3
+o,ind);}
+o<<std::flush;}
+#endif
+}
+#endif
+using
+iR2
+l21;using
+iR2
+FUNCTIONPARSERTYPES;
+#include <cctype>
+iR2
+l21{unsigned
+ParamSpec_GetDepCode
+cY1
+cS2&b){switch(b.first
+e53
+ParamHolder:{cQ*s=(cQ*)b.second
+eO
+s->depcode
+cT1
+SubFunction:{cR*s=(cR*)b.second
+eO
+s->depcode;}
+y13
+break
+yC3
+0;}
+x73
+DumpParam
+cY1
+cS2&x02,std::ostream&o){static
+const
+char
+ParamHolderNames[][2]={"%"
+,"&"
+,"x"
+,"y"
+,"z"
+,"a"
+,"b"
+,"c"
+}
+;unsigned
+xU2
+0;switch(x02.first
+e53
+NumConstant:{const
+ParamSpec_NumConstant
+yB
+y63
+cY1
+ParamSpec_NumConstant
+yB*e62;using
+iR2
+FUNCTIONPARSERTYPES;o.precision(12);o<<yA3
+constvalue;break
+cT1
+ParamHolder:{cQ
+y63(cQ*e62;o<<ParamHolderNames[yA3
+index];xU2
+yA3
+constraints;break
+cT1
+SubFunction:{cR
+y63(cR*e62;xU2
+yA3
+constraints;yN
+GroupFunction){l93
+l51==cNeg){o<<"-"
+;n1}
+i81
+yA3
+l51==cInv){o<<"/"
+;n1}
+else{std
+yE3
+opcode=eK3((nW2)yA3
+l51).substr(1);n72
+0;a<opcode.size();++a)opcode[a]=(char)std::toupper(opcode[a]);o<<opcode<<"( "
+;n1
+o<<" )"
+;}
+}
+else{o<<'('<<eK3((nW2)yA3
+l51)<<' ';yN
+PositionalParams)o<<'[';yN
+SelectedParams)o<<'{';n1
+l93
+data.n0!=0)o<<" <"
+<<yA3
+data.n0<<'>';yN
+PositionalParams)o<<"]"
+;yN
+SelectedParams)o<<"}"
+;o<<')';}
+yN3
+switch(ImmedConstraint_Value(constraints&ValueMask)e53
+ValueMask:lD
+Value_AnyNum:lD
+nK2:o<<"@E"
+;lD
+Value_OddInt:o<<"@O"
+;lD
+tM1:o<<"@I"
+;lD
+Value_NonInteger:o<<"@F"
+;lD
+eQ1:o<<"@L"
+;y73
+ImmedConstraint_Sign(constraints&SignMask)e53
+SignMask:lD
+Sign_AnySign:lD
+n91:o<<"@P"
+;lD
+eR1:o<<"@N"
+;y73
+ImmedConstraint_Oneness(constraints&OnenessMask)e53
+OnenessMask:lD
+Oneness_Any:lD
+Oneness_One:o<<"@1"
+;lD
+Oneness_NotOne:o<<"@M"
+;y73
+ImmedConstraint_Constness(constraints&ConstnessMask)e53
+ConstnessMask:lD
+tL1:if(x02.first==ParamHolder){cQ
+y63(cQ*e62;l93
+index<2)yY3
+o<<"@C"
+;lD
+Constness_NotConst:o<<"@V"
+;lD
+Oneness_Any:yN3
+x73
+DumpParams
+nD2
+paramlist,unsigned
+count,std::ostream&o){for
+nD2
+a=0;a<count;++a
+cI3
+a>0)o<<' ';const
+cS2&param=cR1
+yB(paramlist,a);DumpParam
+yB(param,o);unsigned
+depcode=ParamSpec_GetDepCode(param);if(depcode!=0)o<<"@D"
+<<depcode;}
+}
+}
+#include <algorithm>
+using
+iR2
+l21;using
+iR2
+FUNCTIONPARSERTYPES;iR2{cQ
+plist_p[37]={{2,0,0x0}
+x9
+0,0x4}
+x9
+n91,0x0}
+x9
+eR1|Constness_NotConst,0x0}
+x9
+Sign_NoIdea,0x0}
+x9
+eQ1,0x0}
+,{3,Sign_NoIdea,0x0}
+,{3,0,0x0}
+,{3,eQ1,0x0}
+,{3,0,0x8}
+,{3,Value_OddInt,0x0}
+,{3,Value_NonInteger,0x0}
+,{3,nK2,0x0}
+,{3,n91,0x0}
+,{0,eR1|lW{0,lW{0,n91|lW{0,nK2|lW{0,tL1,0x1}
+,{0,tM1|n91|lW{0,tN1
+tL1,0x1}
+,{0,tN1
+lW{0,Oneness_One|lW{0,eQ1|lW{1,lW{1,nK2|lW{1,tN1
+lW{1,tM1|lW{1,n91|lW{1,eR1|lW{6,0,0x0}
+,{4,0,0x0}
+,{4,tM1,0x0}
+,{4,lW{4,0,0x16}
+,{5,0,0x0}
+,{5,lW}
+;yD
+cP2
+plist_n_container{static
+const
+ParamSpec_NumConstant
+yB
+plist_n[20];}
+;yD
+const
+ParamSpec_NumConstant
+yB
+plist_n_container
+yB::plist_n[20]={{l62(-2
+i3-1
+i3-0.5
+i3-0.25
+i3
+0
+t72
+fp_const_deg_to_rad
+yB(t72
+fp_const_einv
+yB(t72
+fp_const_log10inv
+yB(i3
+0.5
+t72
+fp_const_log2
+yB(i3
+1
+t72
+fp_const_log2inv
+yB(i3
+2
+t72
+fp_const_log10
+yB(t72
+fp_const_e
+yB(t72
+fp_const_rad_to_deg
+yB(t72-fp_const_pihalf
+yB(),xG1{tD1),xG1{fp_const_pihalf
+yB(),xG1{fp_const_pi
+yB(),xG1}
+;cR
+plist_s[517]={{{1,15,t82
+398,t82
+477,t82
+15,cNeg,GroupFunction,0}
+,tL1,0x1
+tL3
+15,xV2
+24,xV2
+465,xV2
+466,xV2
+498,cInv,lU
+2,327995
+xC
+eB2
+48276
+xC
+l6
+260151
+xC
+l6
+470171
+xC
+l6
+169126
+xC
+l6
+48418
+xC
+l6
+1328
+xC
+l6
+283962
+xC
+l6
+169275
+xC
+l6
+39202
+xC
+l6
+283964
+xC
+l6
+283973
+xC
+l6
+476619
+xC
+l6
+296998
+xC
+l6
+47
+xC
+SelectedParams,0}
+,0,0x4
+nM
+161839
+xC
+l6
+25036
+xC
+l6
+35847
+xC
+l6
+60440
+xC
+l6
+30751
+xC
+l6
+183474
+xC
+l6
+259318
+xC
+l6
+270599
+xC
+l6
+60431
+xC
+l6
+259119
+xC
+l6
+332066
+xC
+l6
+7168
+xC
+l6
+197632
+xC
+l6
+291840
+xC
+l6
+283648
+xC
+l6
+238866
+xC
+l6
+239902
+xC
+l6
+31751
+xC
+l6
+244743
+xC
+l6
+384022
+xC
+SelectedParams,0}
+,0,0x4
+nM
+385262
+xC
+l6
+386086
+xC
+l6
+393254
+xC
+SelectedParams,0}
+,0,0x5
+nM
+393254
+xC
+l6
+386095
+xC
+l6
+387312
+xC
+l6
+18662
+xC
+l6
+61670
+xC
+l6
+387397
+xC
+l6
+247855
+xC
+SelectedParams,0}
+,0,0x1
+nM
+342063
+xC
+l6
+297007
+xC
+l6
+15820
+xC
+l6
+393263
+xC
+l6
+393263
+xC
+SelectedParams,0}
+,0,0x5
+nM
+161847
+xC
+l6
+258103
+xC
+l6
+249073
+xC
+l6
+249076
+xC
+iF
+0,0
+xC
+nL
+0,0
+tO1
+1,45
+xC
+nL
+1,53
+xC
+nL
+1,54
+xC
+nL
+1,55
+xC
+nL
+1,56
+xC
+nL
+1,26
+xC
+nL
+1,259
+tP
+1}
+,0,0x16
+tL3
+272
+tO1
+1,323
+tP
+1}
+,0,0x16
+tL3
+0
+xC
+nL
+1,21
+xC
+nL
+1,447
+tP
+1}
+nE2
+449
+tP
+1}
+nE2
+0
+tP
+1}
+nE2
+0
+tP
+2}
+nE2
+15
+xC
+nL
+1,24
+tP
+2}
+,0,0x0
+nM
+58392
+tO1
+0,0
+tP
+1}
+,n91,0x0
+nM
+24591
+nC3
+33807
+nC3
+48143
+nC3
+285720
+nC3
+290840
+nC3
+305152,lA
+312400,lA
+39202,lA
+122918,lA
+421926,lA
+429094,lA
+443430,lA
+317834,lA
+329098,lA
+7633,lA
+7706,lA
+7730,lA
+38,lA
+50587,lA
+406528,lA
+24583,lA
+31751,lA
+405511,lA
+321551,xH1
+327713,lA
+322596,lA
+90409,lA
+335174,lA
+327050,lA
+493606,lA
+496678,lA
+503846,lA
+516134,lA
+7217,lA
+333875,lA
+336896,lA
+524326,lA
+509952,lA
+286727,lA
+89103,lA
+92175,lA
+296976,tA1
+324623,l1
+0x14
+nM
+332815,l1
+0x10}
+,{{3,7340056,tA1
+289092,lA
+93200,xH1
+337935
+tF1
+7340060,l1
+t92
+7340176,lA
+338959
+tF1
+7340061,xH1
+7206,lA
+7168,lA
+357414,lA
+368678,lA
+370745
+eV3}
+,{{3,7340177,lA
+39277,tA1
+426398,l1
+t92
+40272286,xH1
+490910,l1
+t92
+40336798,xH1
+50600,lA
+426462,xH1
+490974,xH1
+370726,l1
+0x6
+nM
+371750,l1
+0x6
+nM
+428070
+tF1
+40336862,xH1
+38378,lA
+50671
+tF1
+47662080,lA
+477184,lA
+568320,lA
+371727
+eV3}
+,{{3,15779306,lA
+370703
+eV3
+nM
+39277,lA
+39279,l1
+0x4}
+,{{3,15779238,lA
+39338,tA1
+436262,lA
+508966,lA
+39409,tA1
+296998,tA1
+35847,lA
+15,tA1
+377894,lA
+386063,l1
+0x1
+nM
+15,lA
+7192,lA
+123928,lA
+122904,lA
+30751,lA
+57,lA
+7456,lA
+15674
+tF1
+67579935,lA
+39237,lA
+58768,lA
+62924,lA
+122880,lA
+15760
+tF1
+64009216,l1
+0x0}
+,{{0,0,xM
+0,0,iM
+2,cM1
+2,cN1
+3,cM1
+3,cN1
+38,xM
+1,38,iM
+14,xM
+1,57,xM
+1,16,eA2
+0x0
+nM
+471103,eA2
+0x1
+tL3
+303,xM
+1,323,yF3
+0x0
+nM
+471363,eA2
+0x16
+tL3
+293,cM1
+294,cN1
+295,xM
+1,296,iM
+400,xM
+1,0,xM
+1,460,xM
+1,465,xM
+1,16,eA2
+0x1
+tL3
+57,yF3
+0x1
+tL3
+0,iM
+21,xM
+1,15,eA2
+0x0
+nM
+24591,xM
+1,24,iM
+517,yF3
+0x0
+nM
+46095,lL
+46104,lL
+15397,lL
+287789,lL
+66584,lL
+404763,lL
+62504,lL
+15409,lL
+39951,lL
+24591,lL
+33807,lL
+50200,lL
+62509,lL
+50176,lG,178176,eS1
+0x12
+nM
+283648,lG,19456,lG,27648,lG,91136,lG,86016,lG,488448,lG,14342,lG,58375,lG,46147
+iX
+46151,lG,284679,lG,7183,lG,46159
+iX
+38993
+iX
+50262,lG,50249,lG,283808,lG,284835,lG,24822,lG,10240,lG,11264,lG,7170,lG,7168,lG,17408,lG,164864,lG,237568,lG,242688,eS1
+0x14
+nM
+476160,lG,25607,lG,122895,lG,50252,lG,39374,lG,50183,lG,7192,lG,122911,lG,252979,lG,46155,lG,38919,lG,50268,lG,50269,lG,50253,lG,46191,lG,50296,lG,7563,eS1
+0x10
+nM
+416811,lG,416819,lG,40047,lG,46192
+iX
+415795,lG,40048
+iX
+415787,lG,39016,eS1
+0x5
+nM
+39326
+iX
+39326,lG,39332,eS1
+0x5
+nM
+39333,eS1
+0x1
+nM
+50590
+iX
+50590,lG,39338
+iX
+39338,lG,39335,eS1
+0x5
+nM
+15786
+iX
+146858,lG,39372,lG,39379,lG,39380,lG,39390
+iX
+50654
+iX
+50654,lG,24,eS1
+0x6
+nM
+62,lG,24,lG,62,eS1
+0x6
+nM
+43,lG,43
+iX
+51,lG,51
+iX
+50270,lG,50176
+iX
+50271,lG,39159,lG,39183
+iX
+7168
+iX
+31744,lG,100352,lG,31746,lG,101400,lG,39409
+iX
+39411
+iX
+39411,lG,39420,lG,39420
+iX
+15,lG,39026,eS1
+0x5
+nM
+39422,lG,16384,lG,62853,lG,15360,lG,15,eS1
+0x1
+nM
+16,lG,7183,eS1
+0x1
+nM
+7172,cPow,y21,n91,0x0
+nM
+24591,cPow,lU
+2,50200,cPow,lU
+2,63521,cPow,lU
+2,62500,cPow,lU
+2,50453,cPow,lU
+2,62488,cPow,lU
+1,0,eC3
+7,eC3
+194,eC3
+0,cAcos
+tH3
+cAcosh
+tH3
+cAsin
+tH3
+cAsinh
+nW
+120,cAsinh
+tH3
+cAtan,eB2
+306176,cAtan2
+iG2,cAtan2
+tH3
+cAtanh
+nW
+246,cCeil
+tH3
+cCeil,eV
+1,0,c42
+0,cCos,eV
+1,7,c42
+92,c42
+93,c42
+120,c42
+236,c42
+255,c42
+214,iF2
+236,iF2
+464,iF2
+0,cCosh,eV
+1,0,iF2
+0,eD3
+7,eD3
+92,eD3
+0
+yG3
+7
+yG3
+92
+yG3
+246,cFloor
+tH3
+cFloor
+xZ
+309540,eE3
+eB2
+316708,eE3
+eB2
+316724,eE3
+l0
+3,32513024,eC2
+34627584
+eW
+31493120,eC2
+89213952
+eW
+149042176
+eW
+246647808
+eW
+301234176
+eW
+494360576
+eW
+498558976
+eW
+62933520
+eW
+62933520,eC2
+62933526
+eW
+62933526,eC2
+24670208
+eW
+579378176
+eW
+573578240
+eW
+32513024
+eW
+566254592
+eW
+7900160
+eW
+588822528,cIf
+nW
+120,cInt
+nW
+246,tA2
+0,tA2
+7,tA2
+31,tA2
+194,tA2
+363,tA2
+15,cLog,lU
+1,24,cLog,lU
+1,0,cLog10
+tH3
+cLog2
+iG2,cMax,eB2
+35847,cMax,eB2
+30751,cMax
+tH3
+cMax,AnyParams,1}
+,0,0x4
+nM
+7168,cMin,eB2
+35847,cMin,eB2
+30751,cMin
+tH3
+cMin,AnyParams,1}
+,0,0x4
+nM
+24591,cMin,lU
+1,0,nL2
+7,nL2
+92,nL2
+93,nL2
+120,nL2
+149,nL2
+231,cSin,lB
+0x5
+tL3
+246,nL2
+255,nL2
+254,nL2
+0,cSin,eV
+1,273,cSin,lB
+0x1
+tL3
+214
+xW2
+231,cSinh,lB
+0x5
+tL3
+246
+xW2
+254
+xW2
+255
+xW2
+464
+xW2
+0,cSinh,eV
+1,0
+xW2
+15,cSqrt,lU
+1,0
+c62
+0,cTan,eV
+1,116,cTan,eV
+1,117
+c62
+231
+c62
+246
+c62
+273
+c62
+254
+c62
+255
+c62
+0,xX2
+0,cTanh,eV
+1,213,xX2
+231,xX2
+246,xX2
+254,xX2
+255,xX2
+0,cTrunc,eB2
+15384,cSub,lU
+2,15384,cDiv,lU
+2,476626,cDiv,lU
+2,122937
+x82
+7168
+i52
+tB2
+7168
+x82
+31744
+i52,lB
+0x20
+nM
+31751
+i52,lB
+0x24
+nM
+31751
+x82
+122937,tP1
+iG2,cLess
+tB2
+41984,cLess
+xZ
+41984,cLess,eB2
+7,cLess
+iG2,cLessOrEq,eB2
+296182,cLessOrEq
+iG2
+tC2
+tB2
+41984
+tC2
+xZ
+41984
+tC2,eB2
+7
+tC2
+iG2
+xO2,eB2
+296182
+xO2
+nW
+0
+tB1
+245
+tB1
+7
+tB1
+550
+tB1
+553
+tB1
+554
+tB1
+556
+tB1
+31
+tB1
+559
+tB1
+15
+tB1
+560,cNot,eB2
+7706,lA3
+7168,lA3
+35847,lA3
+30751,lA3
+463903,lA3
+466975,cAnd,iF
+0,0,cAnd,nL
+2,7168,cO3
+7706,cO3
+35847,cO3
+463903,cO3
+466975,cO3
+30751,cOr,iF
+1,0,lC2
+92,lC2
+131,lC2
+245,lC2
+215,lC2
+246,cDeg
+nW
+246,cRad
+iG2,cAbsAnd,l6
+7168,cAbsOr,iF
+1,0,c03
+tH3
+cAbsNotNot,l0
+3,32513024,cAbsIf,lB
+0x0}
+,}
+;}
+iR2
+l21{const
+Rule
+grammar_rules[262]={{ProduceNewTree,17,1,0,{1,0,cAbs
+eD2
+409,{1,146,cAtan
+eD2
+403
+x9
+1324,cAtan2
+eD2
+405
+x9
+307201,cAtan2
+cA
+253174
+x9
+255224,cAtan2
+cA
+259324
+x9
+257274,cAtan2
+eD2
+152,{1,252,cCeil
+l3
+2,1,486,{1,68,xI1
+482,{1,123,xI1
+483,{1,125,xI1
+151,{1,126,xI1
+419,{1,124,xI1
+0,{1,403,cCos,l2
+2,1,246,{1,252,cCos,l2
+18,1,0,{1,400,xI1
+301,{1,406,cCosh,l2
+2,1,246,{1,252,cCosh,l2
+18,1,0,{1,400,cCosh
+l3
+2,1,458,{1,122,cFloor
+eD2
+150,{1,252,cFloor
+l3
+0,1,156,{3,7382016,eI
+549,{3,8430592,eI
+556,{3,8436736,eI
+157,{3,42998784,eI
+550,{3,42999808,eI
+562,{3,43039744,eI
+557,{3,49291264,eI
+538,{3,49325056,eI
+469,{3,1058318,eI
+473,{3,1058324,eI
+473,{3,9438734,eI
+469,{3,9438740,cIf,l2
+0,3,32542225,{3,36732434,cIf,l2
+0,3,32542231,{3,36732440,cIf
+l3
+16,1,573,{3,32513026,cIf
+l3
+16,1,515,{3,455505423,cIf
+l3
+16,1,515,{3,433506837,cIf
+l3
+2,1,78,{1,256,xY2
+69,{1,258,xY2
+404,{1,72,xY2
+159,{1,147,cLog,l2
+0,1,0
+x9
+487425,cMax,tX
+16,1,445
+x9
+eF3
+cMax,tX
+0,1,0
+x9
+483329,cMin,tX
+16,1,446
+x9
+eF3
+cMin,cB
+0,1,153
+x9
+24832,nM2
+0,1,153
+x9
+25854,nM2
+0,1,154
+x9
+130063,iI2
+32055,iI2
+32056,iI2
+32057,iJ2
+166288
+x9
+32137,iI2
+33082,iJ2
+7168
+x9
+12688,iJ2
+7434
+x9
+12553
+nY2
+435
+x9
+46146
+nY2
+436
+x9
+46154
+nY2
+437
+x9
+46150
+nY2
+169
+x9
+83983
+nY2
+168
+x9
+131106
+nY2
+175
+x9
+133154
+nZ2
+476160
+x9
+471055
+nZ2
+274432
+x9
+273423
+nZ2
+251904
+x9
+266274
+nZ2
+251904
+x9
+263186
+nY2
+171,{1,252,lN1
+421,{1,68,lN1
+151,{1,123,lN1
+419,{1,125,lN1
+170,{1,126,lN1
+482,{1,124,lN1
+0,{1,405,lN1
+172,{1,252,cSinh
+l3
+2,1,328,{1,404,cSinh
+l3
+2,1,173,{1,252,xZ2
+0,{1,408,xZ2
+176,{1,410,xZ2
+177,{1,252,cTanh,l2
+0,1,442
+x9
+449551
+cP3
+441
+x9
+450998
+cP3
+167
+x9
+268549
+cP3
+180
+x9
+276749
+cP3
+181
+x9
+276500
+cQ3
+190770
+x9
+189622
+cQ3
+194748
+x9
+193723
+cQ3
+202943
+x9
+196795
+cQ3
+59699
+x9
+298148
+cQ3
+59714
+x9
+325815
+cQ3
+59724
+x9
+343224
+xC
+cB
+2,1,337,{1,333
+tP
+1
+tT
+336,{1,338
+tP
+1}
+}
+iH2
+2,1,340
+x9
+1363
+tS
+342
+x9
+1365
+tS
+463
+x9
+472524
+tS
+47
+x9
+356711
+tS
+349
+x9
+200751
+tS
+360
+x9
+199727
+tS
+480
+x9
+207053
+tS
+481
+x9
+208077
+tS
+417
+x9
+211144
+tS
+209
+x9
+211145
+tS
+418
+x9
+215240
+tS
+212
+x9
+212329
+tS
+204
+x9
+373097
+tS
+211
+x9
+372944
+tS
+217
+x9
+201944
+tS
+221
+x9
+223448
+tS
+367
+x9
+508329
+tS
+219
+x9
+508126
+tS
+224
+x9
+225705
+tS
+223
+x9
+225776
+tS
+365
+x9
+230825
+tS
+426
+x9
+377057
+tS
+497
+x9
+377054
+tS
+497
+x9
+204201
+tS
+426
+x9
+375280
+tS
+224
+x9
+375006,l7
+2,2,407781
+x9
+233698,l7
+2,2,59763
+x9
+233842
+cP3
+372
+x9
+1397,c72
+96
+x9
+24705,c72
+97
+x9
+24708,c72
+444
+x9
+449551,c72
+443
+x9
+eF3
+c72
+101
+x9
+102774,c72
+109
+x9
+107845,c72
+106
+x9
+104773,l5
+0,2,111631
+x9
+109893,l5
+0,2,108559
+x9
+110917,lK
+0
+tT
+113
+x9
+112658,cMul,SelectedParams,0
+tT
+567,{1,52,lK
+1
+tT
+568,{1,42,lK
+1}
+}
+iH2
+2,1,467
+x9
+45516
+i51
+356
+x9
+51555
+i51
+468
+x9
+49612
+i51
+357
+x9
+47459
+i51
+429
+x9
+438699
+i51
+432
+x9
+441774
+i51
+486
+x9
+498726
+i51
+494
+x9
+504870
+i51
+382
+x9
+435579
+i51
+497
+x9
+435709
+i51
+426
+x9
+508287
+i51
+414
+x9
+500092
+i51
+499
+x9
+352744
+i51
+345
+x9
+367092
+i51
+381
+x9
+425318
+i51
+478
+x9
+425460
+i51
+47
+x9
+512501
+i51
+505
+x9
+355817
+i51
+47
+x9
+516598
+i51
+507
+x9
+518182
+i51
+508
+x9
+358896
+i51
+351
+x9
+388605
+i51
+511
+x9
+360939
+i51
+503
+x9
+354788
+i51
+514
+x9
+525350
+i51
+510
+x9
+394343
+i51
+386
+x9
+351347,l5
+2,2,363004
+x9
+361968,l5
+16,1,118
+x9
+1157,l5
+16,1,119
+x9
+1158,l5
+16,1,402
+x9
+411024,l5
+16,2,58768
+x9
+1472,l5
+16,2,15760
+x9
+1474,l5
+17,1,0,{1,400,l5
+17,1,57,{1,14,lK
+0}
+}
+,{ProduceNewTree,4,1,538
+x9
+41
+i52
+l3
+4,1,0
+x9
+5167
+i52
+c9
+41984
+x9
+409641
+i52
+c9
+tY
+cEqual
+c9
+t0
+cEqual
+c9
+t1
+cEqual
+xL1
+24849
+i52
+cA
+tZ
+cEqual
+cA
+lD2
+281873
+i52
+cA
+lA1
+i52
+cA
+l61
+cEqual
+l3
+4,1,562
+x9
+41,tP1
+l3
+4,1,538
+x9
+5167,tP1
+c9
+41984
+x9
+409641,tP1
+c9
+tY
+tP1
+c9
+t0
+tP1
+c9
+t1
+tP1
+xL1
+24849,tP1
+cA
+tZ
+tP1
+cA
+lD2
+281873,tP1
+cA
+lA1,tP1
+cA
+l61
+tP1
+c9
+tY
+yH3
+t0
+yH3
+t1
+cLess
+eD2
+571
+x9
+46080,cLess
+xL1
+24832,cLess
+cA
+xM1
+cLess
+cA
+tZ
+cLess
+cA
+lD2
+281856,cLess
+cA
+nP1
+cLess
+cA
+lA1,cLess
+cA
+l61
+cLess
+l3
+20,1,562
+x9
+409641,yH3
+tY
+y02
+t0
+y02
+t1
+cLessOrEq
+eD2
+565
+x9
+409615,cLessOrEq
+xL1
+24832,cLessOrEq
+cA
+xM1
+cLessOrEq
+cA
+tZ
+cLessOrEq
+cA
+lD2
+281856,cLessOrEq
+cA
+nP1
+cLessOrEq
+cA
+lA1,cLessOrEq
+cA
+l61
+cLessOrEq
+l3
+20,1,562
+x9
+409647,y02
+tY
+c82
+t0
+c82
+t1
+cGreater
+eD2
+539
+x9
+409615
+tC2
+xL1
+24832
+tC2
+cA
+xM1
+cGreater
+cA
+tZ
+cGreater
+cA
+lD2
+281856
+tC2
+cA
+nP1
+cGreater
+cA
+lA1
+tC2
+cA
+l61
+cGreater
+l3
+20,1,538
+x9
+409647,c82
+tY
+cGreaterOrEq
+c9
+t0
+cGreaterOrEq
+c9
+t1
+cGreaterOrEq
+eD2
+572
+x9
+46080
+xO2
+xL1
+24832
+xO2
+cA
+xM1
+cGreaterOrEq
+cA
+tZ
+cGreaterOrEq
+cA
+lD2
+281856
+xO2
+cA
+nP1
+cGreaterOrEq
+cA
+lA1
+xO2
+cA
+l61
+cGreaterOrEq
+l3
+20,1,538
+x9
+409641
+xO2
+l3
+4,1,519,{1,137,cNot
+l3
+16,1,571,{1,2,cNot,l2
+0,1,452
+x9
+eF3
+xF
+0,2,537097,{3,547892744,cAnd,cB
+16,1,566,{1,5,cAnd,AnyParams,1}
+}
+iH2
+16,1,569
+x9
+13314,xF
+16,1,544
+x9
+553498,xF
+16,1,546
+x9
+462369,xF
+16,1,548
+x9
+466465,xF
+0,1,457
+x9
+eF3
+nH
+570
+x9
+13314,nH
+563
+x9
+8197,nH
+541
+x9
+553498,nH
+542
+x9
+462369,nH
+543
+x9
+466465,nH
+564
+x9
+143365,cOr,cB
+4,1,525,{1,137,cNotNot
+l3
+16,1,572,{1,2,cNotNot
+l3
+17,1,0,{1,0,cNotNot
+eD2
+537,{1,256,cAbsNotNot,cB
+18,1,531,{1,254,cAbsNotNot,cB
+0,1,572,{3,43039744,cAbsIf
+l3
+0,1,571,{3,49325056,cAbsIf
+l3
+16,1,454,{3,32513586,cAbsIf,l2
+16,3,32542225,{3,36732434,cAbsIf,y21}
+,}
+;cP2
+grammar_optimize_abslogical_type{y5
+9
+cV
+grammar_optimize_abslogical_type
+grammar_optimize_abslogical={9,{34,192,228,238,242,247,254,260,261}
+}
+;}
+cP2
+grammar_optimize_ignore_if_sideeffects_type{y5
+59
+cV
+grammar_optimize_ignore_if_sideeffects_type
+grammar_optimize_ignore_if_sideeffects={59,{0,20,21,22,23,24,25,26,cS
+iE1
+78,cT
+cW
+cP2
+grammar_optimize_nonshortcut_logical_evaluation_type{y5
+56
+cV
+grammar_optimize_nonshortcut_logical_evaluation_type
+grammar_optimize_nonshortcut_logical_evaluation={56,{0,25,cS
+iE1
+78,cT
+241,243,244,245,246,248,249,250,251,252,253,255,256,257,258,259}
+}
+;}
+cP2
+grammar_optimize_recreate_type{y5
+22
+cV
+grammar_optimize_recreate_type
+grammar_optimize_recreate={22,{18,55,56,57,80,81,82,83,84,85,117,118,120,121,130,131,132,133,134,135,136,137}
+}
+;}
+cP2
+grammar_optimize_round1_type{y5
+125
+cV
+grammar_optimize_round1_type
+grammar_optimize_round1={125,{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,19,25,cS
+37,38,iE1
+45,46,47,48,49,50,51,52,53,54,58,59,60,61,62,63,64,65,66,67,68,69,70,71,78,79,80,81,82,83,84,85,86,87,88,93,94,95,96,97,98,99,100,101,117,118,119,120,121,122,123,124,125,126,127,128,129,138,160,161,162,163,164,165,166,167,168,169,178,179,180,200,204,212,216,224,236,237,239,240,cW
+cP2
+grammar_optimize_round2_type{y5
+103
+cV
+grammar_optimize_round2_type
+grammar_optimize_round2={103,{0,15,16,17,25,cS
+39,40,iE1
+45,46,47,48,49,50,51,52,53,54,59,60,72,73,78,79,86,87,88,89,90,91,92,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,119,122,123,124,125,126,127,128,139,159,160,161,162,163,164,165,166,167,168,169,178,179,180,200,204,212,216,224,236,237,239,240,cW
+cP2
+grammar_optimize_round3_type{y5
+79
+cV
+grammar_optimize_round3_type
+grammar_optimize_round3={79,{74,75,76,77,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,170,171,172,173,174,175,176,177,181,182,183,184,185,186,187,188,189,190,191,193,194,195,196,197,198,199,201,202,203,205,206,207,208,209,210,211,213,214,215,217,218,219,220,221,222,223,225,226,227,229,230,231,232,233,234,235}
+}
+;}
+cP2
+grammar_optimize_round4_type{y5
+12
+cV
+grammar_optimize_round4_type
+grammar_optimize_round4={12,{18,55,56,57,130,131,132,133,134,135,136,137}
+}
+;}
+cP2
+grammar_optimize_shortcut_logical_evaluation_type{y5
+53
+cV
+grammar_optimize_shortcut_logical_evaluation_type
+grammar_optimize_shortcut_logical_evaluation={53,{0,25,cS
+iE1
+78,cT
+cW}
+iR2
+l21{yD
+cS2
+cR1
+nD2
+paramlist,lB1){index=(paramlist>>(index*10))&1023;if(index>=57)return
+cS2(SubFunction,c92
+plist_s[index-57]);if(index>=37)return
+cS2(NumConstant,c92
+plist_n_container
+yB::plist_n[index-37])eO
+cS2(ParamHolder,c92
+plist_p[index]);}
+}
+#ifdef FP_SUPPORT_OPTIMIZER
+#include <stdio.h>
+#include <algorithm>
+#include <map>
+#include <sstream>
+using
+iR2
+FUNCTIONPARSERTYPES;using
+iR2
+l21;using
+tC;using
+cV1;iR2{nH1
+It,typename
+T,typename
+Comp>eT1
+MyEqualRange(It
+first,It
+last,const
+T&val,Comp
+comp){size_t
+len=last-first;while(len>0){size_t
+xH3
+len/2;It
+nQ3(first);nQ3+=half;if(comp(*nQ3,val)){first=nQ3;++first;len=len-half-1;}
+i81
+comp(val,*nQ3)){len=half;}
+else{It
+left(first);{It&eL2=left;It
+last2(nQ3);size_t
+len2=last2-eL2;while(len2>0){size_t
+half2=len2/2;It
+middle2(eL2);middle2+=half2;if(comp(*middle2,val)){eL2=middle2;++eL2;len2=len2-half2-1;}
+else
+len2=half2;}
+}
+first+=len;It
+right(++nQ3);{It&eL2=right;It&last2=first;size_t
+len2=last2-eL2;while(len2>0){size_t
+half2=len2/2;It
+middle2(eL2);middle2+=half2;if(comp(val,*middle2))len2=half2;else{eL2=middle2;++eL2;len2=len2-half2-1;}
+}
+}
+return
+eT1(left,right);}
+}
+return
+eT1(first,first);}
+yD
+cP2
+OpcodeRuleCompare{bool
+eD1()iX2
+tree,unsigned
+y12)const{const
+Rule&rule=grammar_rules[y12]eO
+tree
+nF<rule
+cB2.subfunc_opcode;}
+bool
+eD1()nD2
+y12,xB3)const{const
+Rule&rule=grammar_rules[y12]eO
+rule
+cB2.subfunc_opcode<tree
+nF;}
+}
+;yD
+bool
+TestRuleAndApplyIfMatch
+cY1
+eU2
+xG&tree,bool
+cC{MatchInfo
+yB
+info;lW1
+found(false,e3());if((rule.l71
+LogicalContextOnly)&&!cC{tC1
+if(nE
+IsIntType
+yB::nT3
+cI3
+rule.l71
+NotForIntegers)tC1
+eN3
+rule.l71
+OnlyForIntegers)tC1
+if(nE
+IsComplexType
+yB::nT3
+cI3
+rule.l71
+NotForComplex)tC1
+eN3
+rule.l71
+OnlyForComplex)tC1
+for(;;){
+#ifdef DEBUG_SUBSTITUTIONS
+#endif
+found=TestParams(rule
+cB2,tree,found.specs,info,true);if(found.found)break;if(found.specs.isnull()){fail:;
+#ifdef DEBUG_SUBSTITUTIONS
+DumpMatch
+cA2,false);
+#endif
+return
+e83}
+#ifdef DEBUG_SUBSTITUTIONS
+DumpMatch
+cA2,true);
+#endif
+SynthesizeRule
+cA2)cT2}
+cV1{yD
+bool
+ApplyGrammar
+cY1
+Grammar&tD2,xG&tree,bool
+cC{if(tree.GetOptimizedUsing()==&tD2){
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Already optimized:  "
+yR2
+tree)xO1"\n"
+<<std::flush;
+#endif
+return
+e83
+if(true){bool
+changed
+e23
+switch
+l83{case
+cNot:case
+cNotNot:case
+cAnd:case
+cOr:n72
+0;lB3
+true))nS2
+lD
+cIf:case
+cAbsIf:if(ApplyGrammar(tD2,tQ,i21
+cIf))nS2
+n72
+1;lB3
+cC)nS2
+break;y13
+n72
+0;lB3
+false))nS2}
+if(changed){tree.Mark_Incompletely_Hashed()cT2}
+typedef
+const
+unsigned
+short*lG3;std::pair<lG3,lG3>range=MyEqualRange(tD2.rule_list,tD2.rule_list+tD2.rule_count,tree,OpcodeRuleCompare
+yB())e72
+unsigned
+short>rules;rules.xD3
+range.second-range.first);cX
+if(IsLogisticallyPlausibleParamsMatch(e91
+cB2,tree))rules
+yS2*r);}
+range.first=!rules
+yU3?&rules[0]:0;range.second=!rules
+yU3?&rules[rules.size()-1]+1:0;if(range.first!=range.second){
+#ifdef DEBUG_SUBSTITUTIONS
+if(range.first!=range.second)lC3"Input ("
+<<eK3
+l83<<")["
+<<t7<<"]"
+;if(cC
+std::cout<<"(Logical)"
+;unsigned
+first=iF1,prev=iF1;nA3
+sep=", rules "
+;cX
+if(first==iF1)first=prev=*r;i81*r==prev+1)prev=*r;else
+lC3
+sep<<first;sep=","
+;if(prev!=first)std::cout<<'-'<<prev;first=prev=*r;}
+}
+if(first!=iF1)lC3
+sep<<first;if(prev!=first)std::cout<<'-'<<prev;}
+std::cout<<": "
+yR2
+tree)xO1"\n"
+<<std::flush;}
+#endif
+bool
+changed
+e23
+cX
+#ifndef DEBUG_SUBSTITUTIONS
+if(!IsLogisticallyPlausibleParamsMatch(e91
+cB2,tree))y41
+#endif
+if(TestRuleAndApplyIfMatch(e91,tree,cC){nS2
+yN3
+if(changed){
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Changed."
+<<std::endl
+xO1"Output: "
+yR2
+tree)xO1"\n"
+<<std::flush;
+#endif
+tree.Mark_Incompletely_Hashed()cT2}
+tree.SetOptimizedUsing(&tD2)eO
+e83
+yD
+bool
+ApplyGrammar
+cY1
+void*p,FPoptimizer_CodeTree::cV2
+yS
+ApplyGrammar(*cY1
+Grammar*)p,tree);}
+x73
+ApplyGrammars(FPoptimizer_CodeTree::cV2{
+#ifdef DEBUG_SUBSTITUTIONS
+std
+t83"grammar_optimize_round1\n"
+;
+#endif
+n6
+grammar_optimize_round1
+y22
+#ifdef DEBUG_SUBSTITUTIONS
+std
+t83"grammar_optimize_round2\n"
+;
+#endif
+n6
+grammar_optimize_round2
+y22
+#ifdef DEBUG_SUBSTITUTIONS
+std
+t83"grammar_optimize_round3\n"
+;
+#endif
+n6
+grammar_optimize_round3
+y22
+#ifndef FP_ENABLE_SHORTCUT_LOGICAL_EVALUATION
+#ifdef DEBUG_SUBSTITUTIONS
+std
+t83"grammar_optimize_nonshortcut_logical_evaluation\n"
+;
+#endif
+n6
+grammar_optimize_nonshortcut_logical_evaluation
+y22
+#endif
+#ifdef DEBUG_SUBSTITUTIONS
+std
+t83"grammar_optimize_round4\n"
+;
+#endif
+n6
+grammar_optimize_round4
+y22
+#ifdef FP_ENABLE_SHORTCUT_LOGICAL_EVALUATION
+#ifdef DEBUG_SUBSTITUTIONS
+std
+t83"grammar_optimize_shortcut_logical_evaluation\n"
+;
+#endif
+n6
+grammar_optimize_shortcut_logical_evaluation
+y22
+#endif
+#ifdef FP_ENABLE_IGNORE_IF_SIDEEFFECTS
+#ifdef DEBUG_SUBSTITUTIONS
+std
+t83"grammar_optimize_ignore_if_sideeffects\n"
+;
+#endif
+n6
+grammar_optimize_ignore_if_sideeffects
+y22
+#endif
+#ifdef DEBUG_SUBSTITUTIONS
+std
+t83"grammar_optimize_abslogical\n"
+;
+#endif
+n6
+grammar_optimize_abslogical
+y22
+#undef C
+}
+}
+#endif
+#ifdef FP_SUPPORT_OPTIMIZER
+#include <algorithm>
+#include <assert.h>
+#include <cstring>
+#include <cmath>
+#include <memory> /* for auto_ptr */
+using
+iR2
+FUNCTIONPARSERTYPES;using
+iR2
+l21;using
+tC;using
+cV1;iR2{yD
+bool
+TestImmedConstraints
+nD2
+bitmask,xB3){switch(bitmask&ValueMask
+e53
+Value_AnyNum:case
+ValueMask:lD
+nK2:if(GetEvennessInfo
+cK3
+lE2
+Value_OddInt:if(GetEvennessInfo
+cK3
+nN2
+tM1:if(GetIntegerInfo
+cK3
+lE2
+Value_NonInteger:if(GetIntegerInfo
+cK3
+nN2
+eQ1:if(!IsLogicalValue(tree)c5
+nA1
+SignMask
+e53
+Sign_AnySign:lD
+n91:if(l01
+lE2
+eR1:if(l01
+nN2
+Sign_NoIdea:if(l01
+Unknown
+c5
+nA1
+OnenessMask
+e53
+Oneness_Any:case
+OnenessMask:lD
+Oneness_One:if(!e01
+if(!fp_equal(fp_abs(tree.xE1),l62(1))c5
+lD
+Oneness_NotOne:if(!e01
+if(fp_equal(fp_abs(tree.xE1),l62(1))c5
+nA1
+ConstnessMask
+e53
+Constness_Any:lD
+tL1:if(!e01
+lD
+Constness_NotConst:if(e01
+break
+yC3
+true;}
+t91
+unsigned
+extent,unsigned
+nbits,typename
+eM2=unsigned
+int>cP2
+nbitmap{private:static
+const
+unsigned
+bits_in_char=8;static
+const
+unsigned
+eN2=(yI3
+eM2)*bits_in_char)/nbits;eM2
+data[(extent+eN2-1)/eN2];cV3
+void
+inc(lB1,int
+by=1){data[pos(index)]+=by*eM2(1<<y32);x61
+void
+dec(lB1){inc(index,-1);}
+int
+get(lB1
+yK1(data[pos(index)]>>y32)&mask()lD3
+pos(lB1)yS
+index/eN2
+lD3
+shift(lB1)yS
+nbits*(index%eN2)lD3
+mask()yS(1<<nbits)-1
+lD3
+mask(lB1)yS
+mask()<<y32;}
+}
+;cP2
+c93{int
+SubTrees:8;int
+yB3:8;int
+y42:8;int
+Immeds:8;nbitmap<iE2,2>SubTreesDetail;c93(){std::memset(this,0,yI3*this));}
+c93
+cY1
+c93&b){std::memcpy(this,&b,yI3
+b));}
+c93&eD1=cY1
+c93&b){std::memcpy(this,&b,yI3
+b))eO*this;}
+}
+;yD
+c93
+CreateNeedList_uncached(eP&tE2{c93
+cU1;for
+nD2
+a=0;a<e13
+y52;++a){const
+cS2&x02=cR1
+yB(e13.param_list,a);switch(x02.first
+e53
+SubFunction:{cR
+y63(cR*e62;yN
+GroupFunction)++cU1.Immeds;else{++cU1.SubTrees;assert(param.data.subfunc_opcode<VarBegin);cU1.SubTreesDetail.inc
+y83
+l51);}
+++cU1.y42;break
+cT1
+NumConstant:case
+ParamHolder:++cU1.yB3;++cU1.y42;yN3
+return
+cU1;}
+yD
+c93&CreateNeedList(eP&tE2{typedef
+std::map<eP*,c93>cO1;static
+cO1
+yF1;cO1::xR3
+i=yF1.xI2&tE2;if(i!=yF1.cH1&tE2
+return
+i
+cW2
+eO
+yF1.xN3,std::make_pair(&e13,CreateNeedList_uncached
+yB(tE2))cW2;}
+yD
+xG
+CalculateGroupFunction
+cY1
+cS2&x02,const
+y1
+info){switch(x02.first
+e53
+NumConstant:{const
+ParamSpec_NumConstant
+yB
+y63
+cY1
+ParamSpec_NumConstant
+yB*e62
+eO
+CodeTreeImmed
+y83
+constvalue)cT1
+ParamHolder:{cQ
+y63(cQ*e62
+eO
+cS3
+GetParamHolderValueIfFound
+y83
+index)cT1
+SubFunction:{cR
+y63(cR*e62;xG
+nT3;nT3
+c4
+yA3
+l51);tX2
+iP1).xD3
+yA3
+data
+y52);for
+nD2
+a=0;a<yA3
+data
+y52;++a
+nQ
+tmp(CalculateGroupFunction(cR1
+yB
+y83
+data.param_list,a),info));nT3
+y7
+tmp);}
+tX2
+Rehash()eO
+nT3;}
+}
+return
+xG();}
+}
+cV1{yD
+bool
+IsLogisticallyPlausibleParamsMatch(eP&e13,xB3){c93
+cU1(CreateNeedList
+yB(tE2);size_t
+eG3=t7;if(eG3<size_t(cU1.y42))tF2
+n72
+0;a<eG3;++a){unsigned
+opcode=xP1
+a)nF;switch(opcode
+e53
+cImmed:if(cU1.Immeds>0)cR3
+Immeds;else
+cR3
+yB3;lD
+iE2:case
+cFCall:case
+cPCall:cR3
+yB3;break;y13
+assert(opcode<VarBegin);if(cU1.SubTrees>0&&cU1.SubTreesDetail.get(opcode)>0){cR3
+SubTrees;cU1.SubTreesDetail.dec(opcode);}
+else
+cR3
+yB3;}
+}
+if(cU1.Immeds>0||cU1.SubTrees>0||cU1.yB3>0)tF2
+if(e13.match_type!=AnyParams
+cI3
+0||cU1.SubTrees<0||cU1.yB3<0)tF2}
+return
+true;}
+yD
+lW1
+TestParam
+cY1
+cS2&x02,xB3
+n43
+start_at,y1
+info){switch(x02.first
+e53
+NumConstant:{const
+ParamSpec_NumConstant
+yB
+y63
+cY1
+ParamSpec_NumConstant
+yB*e62;if(!e01
+l62
+imm=tree.xE1;switch
+y83
+modulo
+e53
+Modulo_None:lD
+Modulo_Radians:imm=fp_mod(imm,yG
+imm<tD1))imm
+yQ
+if(imm>fp_const_pi
+yB())imm-=fp_const_twopi
+yB(eP3
+yC3
+fp_equal(imm,yA3
+constvalue)cT1
+ParamHolder:{cQ
+y63(cQ*e62;if(!x5
+return
+cS3
+SaveOrTestParamHolder
+y83
+index,tree)cT1
+SubFunction:{cR
+y63(cR*e62;yN
+GroupFunction
+cI3!x5
+xG
+xN1=CalculateGroupFunction(x02,info);
+#ifdef DEBUG_SUBSTITUTIONS
+DumpHashes(xN1)xO1*cY1
+void**)&xN1.xE1
+xO1"\n"
+xO1*cY1
+void**)&tree.xE1
+xO1"\n"
+;DumpHashes(tree)xO1"Comparing "
+yR2
+xN1)xO1" and "
+yR2
+tree)xO1": "
+xO1(xN1
+xI
+tree)?"true"
+:"false"
+)xO1"\n"
+;
+#endif
+return
+xN1
+xI
+tree);}
+eN3
+start_at.isnull()cI3!x5
+if(tree
+nF!=yA3
+l51
+c5}
+return
+TestParams
+y83
+data,tree,start_at,info,false);}
+}
+}
+return
+e83
+yD
+cP2
+iR
+x92
+MatchInfo
+yB
+info;iR(y62,info(){}
+}
+;x13
+MatchPositionSpec_PositionalParams:eN1
+iR
+yB>{cV3
+iK2
+MatchPositionSpec_PositionalParams
+x72
+n
+yN1
+iR
+yB>(n){}
+}
+;cP2
+iG1
+x92
+iG1(y62{}
+}
+;class
+yO:eN1
+iG1>{cV3
+unsigned
+trypos;iK2
+yO
+x72
+n
+yN1
+iG1>(n),trypos(0){}
+}
+;yD
+lW1
+TestParam_AnyWhere
+cY1
+cS2&x02,xB3
+n43
+start_at,y1
+info,std::vector<bool>&used,bool
+y82{xQ<yO>xB;unsigned
+a;if(!start_at.isnull()){xB=(yO
+eE2
+a=xB->trypos;goto
+retry_anywhere_2;}
+tG2
+yO(t7);a=0;}
+for(tH2{if(used[a])y41
+retry_anywhere
+yJ3
+TestParam(x02,tJ3(eF2);(eG2
+used[a]=true;if(y82
+cS3
+SaveMatchedParamIndex(a);xB->trypos=a
+eO
+lW1(true,xB.get());}
+}
+retry_anywhere_2
+yK3
+goto
+retry_anywhere;}
+}
+return
+e83
+yD
+cP2
+y61
+x92
+MatchInfo
+yB
+info
+e72
+bool>used;iK2
+y61
+x72
+eG3
+y62,info(),used(eG3){}
+}
+;x13
+MatchPositionSpec_AnyParams:eN1
+y61
+yB>{cV3
+iK2
+MatchPositionSpec_AnyParams
+x72
+n,size_t
+m
+yN1
+y61
+yB>(n,y61
+yB(m)){}
+}
+;yD
+lW1
+TestParams(eP&nT,xB3
+n43
+start_at,y1
+info,bool
+y82{if(nT.match_type!=AnyParams
+cI3
+c2!=t7
+c5}
+if(!IsLogisticallyPlausibleParamsMatch(nT,tree))tF2
+switch(nT.match_type
+e53
+PositionalParams:{xQ<yA>xB;unsigned
+a;if(start_at.get()){xB=(yA
+eE2
+a=c2-1;goto
+l81;}
+tG2
+yA(c2);a=0;}
+for(;a<c2;++a){(*xB)[a
+y72
+retry_positionalparams
+yJ3
+TestParam(cZ
+a),tJ3(eF2);(eG2
+y41}
+}
+l81
+yK3
+eH2
+a].info;goto
+retry_positionalparams;}
+yL3--a;goto
+l81;}
+eH2
+0].info
+eO
+e83
+if(y82
+for
+lR1
+cS3
+SaveMatchedParamIndex(a)eO
+lW1(true,xB.get())cT1
+SelectedParams:case
+AnyParams:{xQ<tD>xB
+e72
+bool>used(t7)e72
+unsigned>iL2(c2)e72
+unsigned>y92(c2)tE3{const
+cS2
+x02=cZ
+a);iL2[a]=ParamSpec_GetDepCode(x02);}
+{unsigned
+b=0
+tE3
+if(iL2[a]!=0)y92[b++]=a
+tE3
+if(iL2[a]==0)y92[b++]=a;}
+unsigned
+a;if(start_at.get()){xB=(tD
+eE2
+if(c2==0){a=0;goto
+retry_anyparams_4;}
+a=c2-1;goto
+cP1;}
+tG2
+tD(c2,t7);a=0;if(c2!=0){(*xB)[0
+y72(*xB)[0].used=used;}
+}
+for(;a<c2;++a){yL3(*xB)[a
+y72(*xB)[a].used=used;}
+retry_anyparams
+yJ3
+TestParam_AnyWhere
+yB(cZ
+y92[a]),tree,(eF2,used,y82;(eG2
+y41}
+}
+cP1
+yK3
+eH2
+a].info;used=(*xB)[a].used;goto
+retry_anyparams;}
+cQ1:yL3--a;goto
+cP1;}
+eH2
+0].info
+eO
+e83
+retry_anyparams_4:if(nT.n0!=0
+cI3!TopLevel||!cS3
+HasRestHolder(nT.n0)){nX2
+cC2;cC2.xD3
+t7);for
+nD2
+b=0;b<t7;++b
+cI3
+yM3)y41
+cC2
+yS2
+xP1
+b));yM3=true;if(y82
+cS3
+SaveMatchedParamIndex(b);}
+if(!cS3
+SaveOrTestRestHolder(nT.n0,cC2)){goto
+cQ1;}
+}
+else{x43
+cC2=cS3
+GetRestHolderValues(nT.n0);n72
+0;a<cC2.size();++a){bool
+found
+e23
+for
+nD2
+b=0;b<t7;++b
+cI3
+yM3)y41
+if(cC2[a]xI
+xP1
+b))){yM3=true;if(y82
+cS3
+SaveMatchedParamIndex(b);found=true;yN3
+if(!found){goto
+cQ1;}
+}
+}
+}
+return
+lW1(true,c2?xB.get():0)cT1
+GroupFunction:break
+yC3
+e83}
+#endif
+#ifdef FP_SUPPORT_OPTIMIZER
+#include <algorithm>
+#include <assert.h>
+using
+tC;using
+cV1;iR2{yD
+xG
+xR1
+const
+cS2&x02,y1
+info,bool
+inner=true){switch(x02.first
+e53
+NumConstant:{const
+ParamSpec_NumConstant
+yB
+y63
+cY1
+ParamSpec_NumConstant
+yB*e62
+eO
+CodeTreeImmed
+y83
+constvalue)cT1
+ParamHolder:{cQ
+y63(cQ*e62
+eO
+cS3
+GetParamHolderValue
+y83
+index)cT1
+SubFunction:{cR
+y63(cR*e62;xG
+tree;tree
+c4
+yA3
+l51);for
+nD2
+a=0;a<yA3
+data
+y52;++a
+nQ
+nparam=xR1
+cR1
+yB
+y83
+data.param_list,a),info,true)e12
+nparam);}
+l93
+data.n0!=0){nX2
+trees(cS3
+GetRestHolderValues
+y83
+data.n0));tree.AddParamsMove(trees);if(t7==1){assert(tree tC3()==cAdd||tree tC3()==cMul||tree tC3()==cMin||tree tC3()==cMax||tree tC3()==cAnd||tree tC3()==cOr||tree tC3()==cAbsAnd||tree tC3()==cAbsOr);tree
+iD2
+tQ);}
+i81
+t7==0){switch
+l83{case
+cAdd:case
+cOr
+e93=n31
+0));lD
+cMul:case
+cAnd
+e93=n31
+1));y13
+yN3}
+if(inner)tree.Rehash()eO
+tree;}
+}
+return
+xG();}
+}
+cV1{x73
+SynthesizeRule
+cY1
+eU2
+xG&tree,y1
+info){switch(rule.ruletype
+e53
+ProduceNewTree:{tree
+iD2
+xR1
+cR1
+l91
+0),info,false)eP3
+cT1
+ReplaceParams:y13{std::vector<unsigned>list=cS3
+GetMatchedParamIndexes();std::sort(list.iC2
+list.end());n72
+list.size();a-->0;)tree.DelParam(list[a]);for
+nD2
+a=0;a<rule.repl_param_count;++a
+nQ
+nparam=xR1
+cR1
+l91
+a),info,true)e12
+nparam);}
+yN3}
+}
+#endif
+#ifdef DEBUG_SUBSTITUTIONS
+#include <sstream>
+#include <cstring>
+using
+iR2
+FUNCTIONPARSERTYPES;using
+iR2
+l21;using
+tC;using
+cV1;iR2
+l21{x73
+DumpMatch
+cY1
+eU2
+xB3,const
+y1
+info,bool
+DidMatch,std::ostream&o){DumpMatch
+cA2,DidMatch?tF3"match"
+:tF3"mismatch"
+,o);}
+x73
+DumpMatch
+cY1
+eU2
+xB3,const
+y1
+info,nA3
+eH3,std::ostream&o){static
+const
+char
+ParamHolderNames[][2]={"%"
+,"&"
+,"x"
+,"y"
+,"z"
+,"a"
+,"b"
+,"c"
+}
+;o<<eH3<<" (rule "
+<<(&rule-grammar_rules)<<")"
+<<":\n  Pattern    : "
+;{cS2
+tmp;tmp.first=SubFunction;ParamSpec_SubFunction
+tmp2;tmp2.data=rule
+cB2;tmp.second=c92
+tmp2;DumpParam
+yB(tmp,o);}
+o<<"\n  Replacement: "
+;DumpParams
+l91
+rule.repl_param_count
+eI2
+o<<"  Tree       : "
+yR2
+tree
+eI2
+if(!std::strcmp(eH3,tF3"match"
+))DumpHashes(tree,o);n72
+0;a<cS3
+yL.size();++a
+cI3!cS3
+yL[a].n12)y41
+o<<"           "
+<<ParamHolderNames[a]<<" = "
+yR2
+cS3
+yL[a]eI2}
+xS3
+cS3
+lR.size();++b
+cI3!cS3
+lR[b
+e03)y41
+n72
+0;a<cS3
+lR[b].second.size();++a){o<<"         <"
+<<b<<"> = "
+yR2
+cS3
+lR[b].second[a],o);o<<std::endl;}
+}
+o<<std::flush;}
+}
+#endif
+#include <list>
+#include <algorithm>
+#ifdef FP_SUPPORT_OPTIMIZER
+using
+iR2
+FUNCTIONPARSERTYPES;iR2{yD
+bool
+MarkIncompletes(FPoptimizer_CodeTree::cV2{if(tree.Is_Incompletely_Hashed(t41;bool
+iH1
+e23
+n72
+0
+tH2
+iH1|=MarkIncompletes
+tN3);if(iH1)tree.Mark_Incompletely_Hashed()eO
+iH1;}
+x73
+FixIncompletes(FPoptimizer_CodeTree::cV2{if(tree.Is_Incompletely_Hashed()){n72
+0
+tH2
+FixIncompletes
+tN3);tree
+eM1}
+}
+}
+tC{lC
+Sort()tI3
+Sort();}
+lC
+Rehash(bool
+constantfolding
+cI3
+constantfolding)ConstantFolding(*this);else
+Sort();data
+xE
+yD
+cP2
+cG
+yO3
+l62
+yP3
+cB1=0;
+#if 0
+long
+double
+value=Value;eC=crc32::calc(cY1
+unsigned
+char*)&value,yI3
+value));key^=(key<<24);
+#elif 0
+union{cP2{unsigned
+char
+filler1[16];l62
+v;unsigned
+char
+filler2[16];}
+buf2;cP2{unsigned
+char
+filler3[yI3
+l62)+16-yI3
+x01)];eC;}
+buf1;}
+data;memset(&data,0,yI3
+data));data.buf2.v=Value;eC=data.buf1.key;
+#else
+int
+nU3;l62
+lW2=std::frexp(Value,&x32;eC=nD2(nU3+0x8000)&0xFFFF);if(lW2<0){lW2=-lW2;key=key^0xFFFF;}
+else
+key+=0x10000;lW2-=l62(0.5);key<<=39;key|=lY1(lW2+lW2)*l62(1u<<31))<<8;
+#endif
+lQ
+#ifdef FP_SUPPORT_COMPLEX_NUMBERS
+nH1
+T
+cD2
+std::complex<T> >yO3
+std::complex<T>yP3
+cG<T>::lH3
+NewHash,Value.real());nE
+fphash_t
+temp;cG<T>::lH3
+temp,Value.imag());cB1^=temp.hash2;NewHash.hash2^=temp.hash1;}
+}
+;
+#endif
+#ifdef FP_SUPPORT_LONG_INT_TYPE
+t91
+cD2
+long>yK
+long
+Value){eC=Value;lQ
+#endif
+#ifdef FP_SUPPORT_GMP_INT_TYPE
+t91
+cD2
+GmpInt>yO3
+GmpInt
+yP3
+eC=Value.toInt();lQ
+#endif
+x73
+x42
+yB::Recalculate_Hash_NoRecursion(){fphash_t
+NewHash(lY1
+Opcode)<<56,Opcode*t23(0x1131462E270012B));Depth=1;switch(Opcode
+e53
+cImmed:{cG
+yB::lH3
+NewHash,Value
+eP3
+cT1
+iE2:{cB1|=lY1
+c51<<48
+cA1((lY1
+c51)*11)^t23(0x3A83A83A83A83A0);break
+cT1
+cFCall:case
+cPCall:{cB1|=lY1
+c51<<48
+cA1((~lY1
+c51)*7)^3456789;}
+y13{size_t
+eU1=0;n72
+0;a<y03;++a
+cI3
+x93.xT2>eU1)eU1=x93.xT2;cB1+=((x93
+n02
+hash1*(a+1))>>12)cA1
+x93
+n02
+hash1
+cA1(3)*t23(0x9ABCD801357);NewHash.hash2*=t23(0xECADB912345)cA1(~x93
+n02
+hash2)^4567890;}
+Depth+=eU1;}
+}
+if(Hash!=NewHash){Hash=NewHash;iS1=0;}
+}
+lC
+FixIncompleteHashes(){MarkIncompletes(*this);FixIncompletes(*this);}
+}
+#endif
+#include <cmath>
+#include <list>
+#include <cassert>
+#ifdef FP_SUPPORT_OPTIMIZER
+using
+iR2
+FUNCTIONPARSERTYPES;iR2{using
+tC;yD
+bool
+nQ1
+xB3,long
+count,const
+x51::SequenceOpCode
+yB&eR,x51
+yZ3&synth,size_t
+max_bytecode_grow_length);static
+const
+cP2
+SinCosTanDataType{OPCODE
+whichopcode;OPCODE
+inverse_opcode;enum{nominator,lX2,inverse_nominator,lC1}
+;OPCODE
+codes[4];}
+SinCosTanData[12]={{cTan,cCot,{cSin,cCos,cCsc,cSec}
+}
+,{cCot,cCot,{cCos,cSin,cSec,cCsc}
+}
+,{cCos,cSec,{cSin,cTan,cCsc,cCot}
+}
+,{cSec,cCos,{cTan,cSin,cCot,cCsc}
+}
+,{cSin,cCsc,{cCos,cCot,cSec,cTan}
+}
+,{cCsc,cSin,{cCot,cCos,cTan,cSec}
+}
+,{cE2{cSinh,cCosh,cF2,{cSinh,cNop,{cE2
+cNop,cCosh}
+}
+,{cCosh,cNop,{cSinh,cE2
+cNop}
+}
+,{cNop,cTanh,{cCosh,cSinh,cF2,{cNop,cSinh,{cNop,cTanh,cCosh,cNop}
+}
+,{cNop,cCosh,{cTanh,cSinh,cF2}
+;}
+tC{lC
+SynthesizeByteCode(std::vector<unsigned>&eE1,std::vector
+yB&Immed,size_t&stacktop_max){
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Making bytecode for:\n"
+;iQ
+#endif
+while(RecreateInversionsAndNegations()){
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"One change issued, produced:\n"
+;iQ
+#endif
+FixIncompleteHashes();using
+cV1;using
+iR2
+l21;const
+void*g=c92
+grammar_optimize_recreate;while(ApplyGrammar(*cY1
+Grammar*)g,*this)){FixIncompleteHashes();}
+}
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Actually synthesizing, after recreating inv/neg:\n"
+;iQ
+#endif
+x51
+yZ3
+synth;SynthesizeByteCode(synth,false
+i62.Pull(eE1,Immed,stacktop_max);}
+lC
+SynthesizeByteCode(x51
+yZ3&synth,bool
+MustPopTemps)const{xS1*this))yS;}
+n72
+0;a<12;++a){const
+SinCosTanDataType&data=SinCosTanData[a];if(data.whichopcode!=cNop)l22!=data.whichopcode)y41
+CodeTree
+lI3;lI3.lH1
+lI3
+yQ3
+inverse_opcode);lI3.lF2
+xS1
+lI3)){synth.iU
+else
+l22!=cInv)y41
+if(GetParam(0)nF!=data.inverse_opcode)y41
+xS1
+GetParam(0))){synth.iU
+size_t
+found[4];xS3
+4;++b){CodeTree
+tree;if(data.eI3]==cNop){tree
+c4
+cInv);CodeTree
+lJ3;lJ3.lH1
+lJ3
+yQ3
+eI3^2]);lJ3.lF2
+tree
+y7
+lJ3);}
+else{tree.lH1
+tree
+yQ3
+eI3]);}
+tree.lF2
+found[b]eJ3
+xF3
+tree);}
+if(found[data.yA2!=tR
+lX2]!=iS
+yA2
+i62.yV
+lX2
+iT
+cDiv
+iV
+yA2!=tR
+lC1]!=iS
+yA2
+i62.yV
+lC1
+iT
+cMul
+iV
+lO1!=tR
+lC1]!=iS
+lO1
+i62.yV
+lC1
+iT
+cRDiv
+iV
+lO1!=tR
+lX2]!=iS
+lO1
+i62.yV
+lX2
+iT
+cMul,2,1
+i62.iU
+size_t
+n_subexpressions_synthesized=SynthCommonSubExpressions(synth);switch(l42{case
+iE2:synth.PushVar(GetVar());lD
+cImmed:eV1
+xE1);lD
+cAdd:case
+cMul:case
+cMin:case
+cMax:case
+cAnd:case
+cOr:case
+cAbsAnd:case
+cAbsOr:l22==cMul){bool
+yR3
+e23
+yP
+lP1
+yP2)&&isLongInteger(lP1.xE1)){yO1=makeLongInteger(lP1.xE1);CodeTree
+tmp(*this,typename
+CodeTree::CloneTag());tmp.DelParam(a);tmp
+eM1
+if(nQ1
+tmp,value,x51::tH1
+yB::AddSequence,synth,MAX_MULI_BYTECODE_LENGTH)){yR3=true;yN3}
+if(yR3)yY3
+int
+y71=0
+e72
+bool>done(GetParamCount(),false);CodeTree
+iG;iG
+c4
+l42;for(;;){bool
+found
+e23
+yP
+done[a])y41
+if(synth.IsStackTop(lP1)){found=true;done[a]=true;lP1.n8
+iG
+cM
+lP1);if(++y71>1){yW
+2);iG.Rehash(false)cZ1
+iG);y71=y71-2+1;}
+}
+}
+if(!found)yY3
+yP
+done[a])y41
+lP1.n8
+iG
+cM
+lP1);if(++y71>1){yW
+2);iG.Rehash(false)cZ1
+iG);y71=y71-2+1;}
+}
+if(y71==0){switch(l42{case
+cAdd:case
+cOr:case
+cAbsOr:eV1
+0);lD
+cMul:case
+cAnd:case
+cAbsAnd:eV1
+1);lD
+cMin:case
+cMax:eV1
+0
+eP3;y13
+yY3++y71;}
+assert(n_stacked==1);break
+cT1
+cPow:{iS2
+p0
+nT2
+0);iS2
+p1
+nT2
+1);if(!p1
+yP2)||!isLongInteger(p1.xE1)||!nQ1
+p0,makeLongInteger(p1.xE1),x51::tH1
+yB::MulSequence,synth,MAX_POWI_BYTECODE_LENGTH)){p0.n8
+p1.n8
+yW
+2);i31
+cIf:case
+cAbsIf:{typename
+x51
+yZ3::IfData
+nP3;GetParam(0).n8
+synth.SynthIfStep1(nP3,l42;GetParam(1).n8
+synth.SynthIfStep2(nP3);GetParam(2).n8
+synth.SynthIfStep3(nP3
+eP3
+cT1
+cFCall:case
+cPCall:{n72
+0;a<x31++a)lP1.n8
+yW
+nD2)GetParamCount());n42
+0x80000000u|GetFuncNo(),0,0);yY3
+y13{n72
+0;a<x31++a)lP1.n8
+yW
+nD2)GetParamCount());yN3
+synth.StackTopIs(*this);if(MustPopTemps&&n_subexpressions_synthesized>0){size_t
+top
+eJ3
+GetStackTop(i62.DoPopNMov(top-1-n_subexpressions_synthesized,top-1);}
+}
+}
+iR2{yD
+bool
+nQ1
+xB3,long
+count,const
+x51::SequenceOpCode
+yB&eR,x51
+yZ3&synth,size_t
+max_bytecode_grow_length
+cI3
+count!=0){x51
+yZ3
+backup=synth;tree.n8
+size_t
+bytecodesize_backup
+eJ3
+GetByteCodeSize();x51::nQ1
+count
+n32
+size_t
+bytecode_grow_amount
+eJ3
+GetByteCodeSize()-bytecodesize_backup;if(bytecode_grow_amount>max_bytecode_grow_length){synth=backup
+eO
+false
+yC3
+true;}
+else{x51::nQ1
+count,eR,synth)cT2}
+}
+#endif
+#include <cmath>
+#include <cassert>
+#ifdef FP_SUPPORT_OPTIMIZER
+using
+iR2
+FUNCTIONPARSERTYPES;iR2{using
+tC;
+#define FactorStack std::vector
+const
+cP2
+PowiMuliType{unsigned
+opcode_square;unsigned
+opcode_cumulate;unsigned
+opcode_invert;unsigned
+opcode_half;unsigned
+opcode_invhalf;}
+iseq_powi={cSqr,cMul,cInv,cSqrt,cRSqrt}
+,iseq_muli={iF1
+xC
+cNeg,iF1,iF1}
+;yD
+l62
+c61
+const
+PowiMuliType&yS3,t51,lG2&stack){l62
+nT3(1);while(IP<limit
+cI3
+lK3
+yS3.opcode_square
+cI3!t12
+nT3))lH2
+2;c0
+opcode_invert){nT3=-nT3;c0
+opcode_half
+cI3
+nT3>tD1)&&isEvenInteger(nT3))lH2
+l62(0.5);c0
+opcode_invhalf
+cI3
+nT3>tD1)&&isEvenInteger(nT3))lH2
+l62(-0.5);++IP;y41}
+size_t
+nO2=IP;l62
+lhs(1);if(lK3
+cFetch){lB1=lL3;if(index<y4||size_t(index-y4)>=iK1){IP=nO2;yY3
+lhs=stack[index-y4];goto
+yB2;}
+if(lK3
+cDup){lhs=nT3;goto
+yB2;yB2:eW1
+nT3);++IP;l62
+subexponent=c61
+yS3
+i0
+if(IP>=limit||eE1[IP]!=yS3.opcode_cumulate){IP=nO2;yY3++IP;stack.pop_back();nT3+=lhs*subexponent;y41}
+break
+yC3
+nT3;}
+yD
+l62
+ParsePowiSequence(t51){lG2
+stack;eW1
+l62(1))eO
+c61
+iseq_powi
+i0}
+yD
+l62
+ParseMuliSequence(t51){lG2
+stack;eW1
+l62(1))eO
+c61
+iseq_muli
+i0}
+x13
+CodeTreeParserData{cV3
+iK2
+CodeTreeParserData(bool
+k_powi):stack(),clones(),keep_powi(k_powi){}
+void
+Eat
+x72
+eG3,OPCODE
+opcode
+nQ
+xN;xN
+c4
+opcode);nX2
+e13=Pop(eG3);xN
+iY1
+tE2;if(!keep_powi)switch(opcode
+e53
+cTanh:{xG
+sinh,cosh;sinh
+c4
+cSinh);sinh
+cM
+xN
+xN2
+sinh
+eM1
+cosh
+c4
+cCosh);cosh
+y7
+xN
+xN2
+cosh
+eM1
+xG
+pow;pow
+c4
+cPow);pow
+y7
+cosh);pow.yJ
+l62(-1)));pow
+eM1
+xN
+c4
+yT3.n41
+0,sinh);xN
+y7
+pow
+eP3
+cT1
+cTan:{xG
+sin,cos;sin
+c4
+cSin);sin
+cM
+xN
+xN2
+sin
+eM1
+cos
+c4
+cCos);cos
+y7
+xN
+xN2
+cos
+eM1
+xG
+pow;pow
+c4
+cPow);pow
+y7
+cos);pow.yJ
+l62(-1)));pow
+eM1
+xN
+c4
+yT3.n41
+0,sin);xN
+y7
+pow
+eP3
+cT1
+cPow:{iT1
+p0=xN
+l8
+0);iT1
+p1=xN
+l8
+1);if(p1
+nF==cAdd){nX2
+i82(p1.GetParamCount());n72
+0;a<p1.x31++a
+nQ
+pow;pow
+c4
+cPow);pow
+cM
+p0);pow
+cM
+p1
+lS3
+pow
+eM1
+i82[a
+eO3
+pow);}
+xN
+c4
+yT3
+iY1
+i82);}
+yY3
+y13
+yY3
+xN.Rehash(!keep_powi);iI1,false);
+#ifdef DEBUG_SUBSTITUTIONS
+iJ1<<eG3<<", "
+<<eK3(opcode)<<"->"
+<<eK3(xN
+nF)<<": "
+t93
+xN)iW
+xN);
+#endif
+eW1
+xN
+n33
+EatFunc
+x72
+eG3,OPCODE
+cW3
+unsigned
+funcno
+nQ
+xN=CodeTreeFuncOp
+yB(cW3
+funcno);nX2
+e13=Pop(eG3);xN
+iY1
+tE2;xN.lF2
+#ifdef DEBUG_SUBSTITUTIONS
+iJ1<<eG3<<", "
+t93
+xN)iW
+xN);
+#endif
+iI1);eW1
+xN
+n33
+xU
+yB1
+nQ
+xN=CodeTreeImmed(value);iI1);Push(xN
+n33
+AddVar
+nD2
+varno
+nQ
+xN=CodeTreeVar
+yB(varno);iI1);Push(xN
+n33
+SwapLastTwoInStack(){eX1
+1
+eO3
+eX1
+2]n33
+Dup(){Fetch(iK1-1
+n33
+Fetch
+x72
+which){Push(stack[which]);}
+nH1
+T>void
+Push(T
+tree){
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<t93
+tree)iW
+tree);
+#endif
+eW1
+tree
+n33
+PopNMov
+x72
+target,size_t
+source){stack[target]=stack[source];stack
+x53
+target+1);}
+xG
+yC2{clones.clear();xG
+nT3(stack.back());stack
+x53
+iK1-1)eO
+nT3;}
+nX2
+Pop
+x72
+n_pop){nX2
+nT3(n_pop);for
+nD2
+n=0;n<n_pop;++n)nT3[n
+eO3
+eX1
+n_pop+n]);
+#ifdef DEBUG_SUBSTITUTIONS
+for
+x72
+n=n_pop;n-->0;){iJ1
+yR2
+nT3[n])iW
+nT3[n]);}
+#endif
+stack
+x53
+iK1-n_pop)eO
+nT3;}
+size_t
+GetStackTop(yK1
+iK1;}
+private:void
+FindClone(xG&,bool=true)yS;}
+private:nX2
+stack;std::multimap<fphash_t,xG>clones;bool
+keep_powi;private:CodeTreeParserData
+cY1
+CodeTreeParserData&);CodeTreeParserData&eD1=cY1
+CodeTreeParserData&);}
+;yD
+cP2
+IfInfo{xG
+eO2;xG
+thenbranch;size_t
+endif_location;IfInfo():eO2(),thenbranch(),endif_location(){}
+}
+;}
+tC{lC
+GenerateFrom
+cY1
+typename
+FunctionParserBase
+yB::Data&nR3,bool
+keep_powi){nX2
+x12;x12.xD3
+nR3.mVariablesAmount);for
+nD2
+n=0;n<nR3.mVariablesAmount;++n){x12
+yS2
+CodeTreeVar
+yB(n+iE2));}
+GenerateFrom(nR3,x12,keep_powi);}
+lC
+GenerateFrom
+cY1
+typename
+FunctionParserBase
+yB::Data&nR3,const
+x7&x12,bool
+keep_powi){yL1
+unsigned>&eE1=nR3.mByteCode;const
+std::vector
+yB&Immed=nR3.mImmed;
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"ENTERS GenerateFrom()\n"
+;
+#endif
+CodeTreeParserData
+yB
+sim(keep_powi)e72
+IfInfo
+yB>eN;for
+x72
+IP=0,DP=0;;++IP){tK2:while(!eN
+yU3&&(eN.eD==IP||(IP<lX1&&lK3
+cJump&&eN.eA1.n12))){CodeTree
+elsebranch=sim.yC2
+n92
+eN.back().eO2)n92
+eN.eA1)n92
+elsebranch);sim.Eat(3,cIf);eN.pop_back();}
+if(IP>=lX1)break;unsigned
+opcode=eE1[IP];if((opcode==cSqr||opcode==cDup||(opcode==cInv&&!IsIntType
+yB::nT3)||opcode==cNeg||opcode==cSqrt||opcode==cRSqrt||opcode==cFetch)){size_t
+was_ip=IP;l62
+cY2
+ParsePowiSequence
+yB(eE1,IP,eN
+yU3?lX1:eN.eD,sim.xH
+1);if(nU3!=l62(1.0)){sim.xU
+x32
+xX
+cPow);goto
+tK2;}
+if(opcode==cDup||opcode==cFetch||opcode==cNeg){l62
+xH2=ParseMuliSequence
+yB(eE1,IP,eN
+yU3?lX1:eN.eD,sim.xH
+1);if(xH2!=l62(1.0)){sim.xU
+xH2)xX
+cMul);goto
+tK2;}
+}
+IP=was_ip;}
+if(lI2>=iE2){lB1=opcode-iE2
+n92
+x12[index]);}
+else{switch(lI2
+e53
+cIf:case
+cAbsIf:{eN
+x53
+eN.size()+1);CodeTree
+res(sim.yC2);eN.back().eO2.swap(res);eN.eD=lX1;IP+=2;y41}
+case
+cJump:{CodeTree
+res(sim.yC2);eN.eA1.swap(res);eN.eD=eE1[IP+1]+1;IP+=2;y41}
+case
+cImmed:sim.xU
+Immed[DP++]);lD
+cDup:sim.Dup();lD
+cNop:lD
+cFCall:{unsigned
+funcno=lL3;assert(funcno<fpdata.mFuncPtrs.size());unsigned
+e13=nR3.mFuncPtrs
+lM3
+mParams;sim.EatFunc(e13,lI2,funcno
+eP3
+cT1
+cPCall:{unsigned
+funcno=lL3;assert(funcno<fpdata.t63.size());const
+FunctionParserBase
+yB&p=*nR3.t63
+lM3
+mParserPtr;unsigned
+e13=nR3.t63
+lM3
+mParams;x7
+paramlist=sim.Pop(tE2;CodeTree
+tL2;tL2.GenerateFrom(*p.mData,paramlist)n92
+tL2
+eP3
+cT1
+cInv:sim.xU
+1
+lY2
+cDiv);lD
+cNeg:nA2
+cNeg
+eP3;sim.xU
+0
+lY2
+cSub);lD
+cSqr:sim
+c52;lD
+cSqrt
+tM3
+eY1
+cRSqrt
+tM3-eY1
+cCbrt
+tM3
+1)/l62(3))xX
+yV3
+cDeg:sim.xU
+fp_const_rad_to_deg
+e11
+cRad:sim.xU
+fp_const_deg_to_rad
+e11
+cExp:iH)goto
+default_function_handling;sim.xU
+fp_const_e
+yB()lY2
+yV3
+cExp2:iH)goto
+default_function_handling;sim.xU
+2.0
+lY2
+yV3
+cCot:nA2
+cTan);iH)x2
+cCsc:nA2
+cSin);iH)x2
+cSec:nA2
+cCos);iH)x2
+cInt:
+#ifndef __x86_64
+iH){nA2
+cInt);yY3
+#endif
+sim
+i61
+0.5))xX
+cAdd);nA2
+cFloor);lD
+cLog10:nA2
+yD2
+fp_const_log10inv
+e11
+cLog2:nA2
+yD2
+fp_const_log2inv
+e11
+cLog2by:lN3
+yD2
+fp_const_log2inv
+yB());sim.Eat(3,cMul);lD
+cHypot:sim
+c52;sim.nX1
+sim
+c52
+xX
+cAdd);sim
+i61
+eY1
+cSinCos:sim.Dup();nA2
+cSin);lN3
+cCos);lD
+cSinhCosh:sim.Dup();nA2
+cSinh);lN3
+cCosh);lD
+cRSub:sim.nX1
+case
+cSub:iH){sim.Eat(2,cSub);yY3
+sim.xU-1)xX
+cMul)xX
+cAdd);lD
+cRDiv:sim.nX1
+case
+cDiv:iH||IsIntType
+yB::nT3){sim.Eat(2,cDiv);yY3
+sim.xU-1)xX
+cPow)xX
+cMul);lD
+cAdd:case
+cMul:case
+cMod:case
+cPow:case
+cEqual:case
+cLess:case
+cGreater:case
+tP1:case
+cLessOrEq:case
+cGreaterOrEq:case
+cAnd:case
+cOr:case
+cAbsAnd:case
+cAbsOr:sim.Eat(2
+cS1
+lD
+cNot:case
+cNotNot:case
+c03:case
+cAbsNotNot:sim.Eat(1
+cS1
+lD
+cFetch:sim.Fetch(lL3);lD
+cPopNMov:{unsigned
+stackOffs_target=lL3;unsigned
+stackOffs_source=lL3;sim.PopNMov(stackOffs_target,stackOffs_source);yY3
+y13
+default_function_handling:;unsigned
+funcno=opcode-cAbs;assert(funcno<FUNC_AMOUNT);const
+FuncDefinition&func=Functions[funcno];sim.Eat(func.e13
+cS1
+yN3}
+Become(sim.yC2);
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Produced tree:\n"
+;iQ
+#endif
+}
+}
+#endif
+#include <algorithm>
+#ifdef FP_SUPPORT_OPTIMIZER
+#include <assert.h>
+#define FP_MUL_COMBINE_EXPONENTS
+iR2{using
+iR2
+FUNCTIONPARSERTYPES;using
+tC;yD
+static
+void
+AdoptChildrenWithSameOpcode(cV2{
+#ifdef DEBUG_SUBSTITUTIONS
+bool
+lZ2
+e23
+#endif
+for
+c7
+if
+tN3
+nF==tree
+nF){
+#ifdef DEBUG_SUBSTITUTIONS
+if(!lZ2)lC3"Before assimilation: "
+xY
+lZ2=true;}
+#endif
+tree.AddParamsMove
+tN3.GetUniqueRef().iP1),a);}
+#ifdef DEBUG_SUBSTITUTIONS
+if(lZ2)lC3"After assimilation:   "
+xY}
+#endif
+}
+}
+tC{x73
+ConstantFolding(cV2{tree.Sort();
+#ifdef DEBUG_SUBSTITUTIONS
+void*yW3=0
+xO1"["
+<<(&yW3)<<"]Runs ConstantFolding for: "
+xY
+DumpHashes(tree)xO1
+std::flush;
+#endif
+if(false){redo:;tree.Sort();
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"["
+<<(&yW3)<<"]Re-runs ConstantFolding: "
+xY
+DumpHashes(tree);
+#endif
+}
+if(tree
+nF!=cImmed){range
+yB
+p=iO
+tree);if(p
+eY&&p
+t6
+cF3==p
+nV){tree.ReplaceWithImmed(p
+e32
+l32}
+}
+if(false){ReplaceTreeWithOne
+e93.ReplaceWithImmed(l62(1)l32
+ReplaceTreeWithZero
+e93.ReplaceWithImmed(tD1)l32
+ReplaceTreeWithParam0:
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Before replace: "
+xO1
+std::hex<<'['<<tree
+n02
+hash1<<','<<tree
+n02
+hash2<<']'<<std::dec
+xY
+#endif
+tree
+iD2
+tQ);
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"After replace: "
+xO1
+std::hex<<'['<<tree
+n02
+hash1<<','<<tree
+n02
+hash2<<']'<<std::dec
+xY
+#endif
+cN
+yX3
+l83{case
+cImmed:lD
+iE2:lD
+cAnd:case
+cAbsAnd:e0
+bool
+cD
+e23
+for
+c7{if(!IsLogicalValue
+tN3))cD=true;cN3
+tJ3
+i21
+cAbsAnd)e53
+xL3
+tE
+IsAlways:e61);lD
+lS1
+yX3(t7
+e53
+0:iA
+1
+e93
+c4
+i21
+cAnd?cNotNot:cAbsNotNot);cN
+y13
+if(i21
+cAnd||!cD)if(ConstantFolding_AndLogic(e82
+i31
+cOr:case
+cAbsOr:e0
+bool
+cD
+e23
+for
+c7{if(!IsLogicalValue
+tN3))cD=true;cN3
+tJ3
+i21
+cAbsOr))i71
+iA
+iO2
+e61);lD
+lS1
+yX3(t7
+e53
+0
+tE
+1
+e93
+c4
+i21
+cOr?cNotNot:cAbsNotNot);cN
+y13
+if(i21
+cOr||!cD)if(ConstantFolding_OrLogic(e82
+i31
+cNot:case
+c03:{unsigned
+lZ1
+0;switch(tQ
+nF
+e53
+cEqual:lZ1
+tP1;lD
+tP1:lZ1
+cEqual;lD
+cLess:lZ1
+cGreaterOrEq;lD
+cGreater:lZ1
+cLessOrEq;lD
+cLessOrEq:lZ1
+cGreater;lD
+cGreaterOrEq:lZ1
+cLess;lD
+cNotNot:lZ1
+cNot;lD
+cNot:lZ1
+cNotNot;lD
+c03:lZ1
+cAbsNotNot;lD
+cAbsNotNot:lZ1
+c03;break;y13
+yY3
+if(opposite){tree
+c4
+OPCODE(opposite));tree
+iY1
+tQ.GetUniqueRef().iP1));cN
+yX3
+nR1
+tQ,tree
+c71
+e53
+IsAlways
+tE
+iO2
+iA
+lS1
+if(i21
+cNot&&GetPositivityInfo(tQ)==IsAlways)tree
+c4
+c03);if(e43
+cIf||e43
+cAbsIf
+nQ
+iM2=tQ;iT1
+ifp1=iM2
+l8
+1);iT1
+ifp2=iM2
+l8
+2);if(ifp1
+nF==cNot||ifp1
+c71
+tG3
+ifp1
+nF==cNot?cNotNot:cAbsNotNot);tM2
+l8
+0))lT1
+cM3
+n82
+p2
+lO3
+p2.lP3
+if(ifp2
+nF==cNot||ifp2
+c71
+tG3
+tree
+nF);tM2)lT1
+cM3
+c4
+ifp2
+nF==cNot?cNotNot:cAbsNotNot);p2
+cM
+ifp2
+xN2
+p2.lP3
+i31
+cNotNot:case
+cAbsNotNot:{if(IsLogicalValue(tQ))goto
+e5
+cN3
+tQ,i21
+cAbsNotNot)e53
+xL3
+tE
+IsAlways:iA
+lS1
+if(i21
+cNotNot&&GetPositivityInfo(tQ)==IsAlways)tree
+c4
+cAbsNotNot);if(e43
+cIf||e43
+cAbsIf
+nQ
+iM2=tQ;iT1
+ifp1=iM2
+l8
+1);iT1
+ifp2=iM2
+l8
+2);if(ifp1
+nF==cNot||ifp1
+c71{tree.SetParam(0,iM2
+xN2
+tree
+cM
+ifp1);cM3
+n82
+p2
+lO3
+p2.lP3
+if(ifp2
+nF==cNot||ifp2
+c71
+tG3
+tree
+nF);tM2)lT1
+tree
+lO3
+tree
+c4
+iM2
+nF);cN}
+i31
+cIf:case
+cAbsIf:{if(ConstantFolding_IfOperations(e82
+break
+cT1
+cMul:{NowWeAreMulGroup:;AdoptChildrenWithSameOpcode(tree);l62
+nB1=l62(1);size_t
+iL1=0;bool
+nC1
+e23
+for
+c6
+if(!xQ1
+y41
+l62
+immed=yE2;if(immed==tD1))goto
+ReplaceTreeWithZero;nB1*=immed;++iL1;}
+if(iL1>1||(iL1==1&&fp_equal(nB1,l62(1))))nC1=true;if(nC1){
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"cMul: Will add new "
+t73
+nB1<<"\n"
+;
+#endif
+for
+c7
+if(xQ1{
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<" - For that, deleting "
+t73
+yE2
+xO1"\n"
+;
+#endif
+lQ3!fp_equal(nB1,l62(1)))tree
+cM
+cL1
+nB1));yX3(t7
+e53
+0:iA
+1:goto
+e5
+y13
+if(ConstantFolding_MulGrouping(e82
+if(ConstantFolding_MulLogicItems(e82
+i31
+cAdd:e0
+l62
+lJ2=0.0;size_t
+iL1=0;bool
+nC1
+e23
+for
+c6
+if(!xQ1
+y41
+l62
+immed=yE2;lJ2+=immed;++iL1;}
+if(iL1>1||(iL1==1&&lJ2==tD1)))nC1=true;if(nC1){
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"cAdd: Will add new "
+t73
+lJ2<<"\n"
+xO1"In: "
+xY
+#endif
+for
+c7
+if(xQ1{
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<" - For that, deleting "
+t73
+yE2
+xO1"\n"
+;
+#endif
+lQ3!(lJ2==l62(0.0)))tree
+cM
+cL1
+lJ2));yX3(t7
+e53
+0
+tE
+1:goto
+e5
+y13
+if(ConstantFolding_AddGrouping(e82
+if(ConstantFolding_AddLogicItems(e82
+i31
+cMin:e0
+size_t
+yF2=0;range
+yB
+e7;for
+c6
+while(a+1<t7&&xP1
+a)xI
+xP1
+a+1)))e61+1);range<l62
+nY
+max
+iN2(!e7
+t6||(p
+nV)<e7
+nV)){e7
+nV=p
+nV;e7
+t6=true;yF2=a;}
+}
+if(e7
+t6)for
+c7{range<l62
+nY
+min
+iN2
+a!=yF2
+cF3>=e7
+nV)lQ3
+t7==1){goto
+e5
+i31
+cMax:e0
+size_t
+yF2=0;range
+yB
+t2;for
+c6
+while(a+1<t7&&xP1
+a)xI
+xP1
+a+1)))e61+1);range<l62
+nY
+min
+iN2(!t2
+eY||p
+e32>t2
+e32)){t2
+e32=p
+e32;t2
+eY=true;yF2=a;}
+}
+if(t2
+eY){for
+c7{range<l62
+nY
+max
+iN2
+a!=yF2&&(p
+nV)<t2
+e32){e61);}
+}
+}
+if(t7==1){goto
+e5
+i31
+cEqual:case
+tP1:case
+cLess:case
+cGreater:case
+cLessOrEq:case
+cGreaterOrEq:if(ConstantFolding_Comparison(e82
+lD
+cAbs:{range
+yB
+p0=tO
+0));if(p0.cK
+goto
+e5
+if(p0.c8{tree
+c4
+cMul);tree.yJ
+l62(1)));goto
+NowWeAreMulGroup;}
+if(e43
+cMul){iT1
+p=tQ;nX2
+lR3;nX2
+cG2;n72
+0;a<p.x31++a){p0=iO
+p
+lS3
+if(p0.cK{lR3
+yS2
+p
+lS3}
+if(p0.c8{cG2
+yS2
+p
+lS3}
+}
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"Abs: mul group has "
+<<lR3.size()<<" pos, "
+<<cG2.size()<<"neg\n"
+;
+#endif
+if(!lR3
+yU3||!cG2
+yU3){
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"AbsReplace-Before: "
+yR2
+tree)xO1"\n"
+<<std::flush;DumpHashes(tree
+cH2;
+#endif
+xG
+cT3;cT3
+c4
+cMul);n72
+0;a<p.x31++a){p0=iO
+p
+lS3
+if((p0.cK||(p0.c8){}
+else
+cT3
+cM
+p
+lS3}
+cT3
+eM1
+xG
+lT3;lT3
+c4
+cAbs);lT3
+y7
+cT3);lT3
+eM1
+xG
+xX1
+cMul);i82
+y7
+lT3);xY1
+AddParamsMove(lR3);if(!cG2
+yU3
+cI3
+cG2.size()%2)xY1
+yJ
+l62(-1)));xY1
+AddParamsMove(cG2);}
+tree
+iD2
+i82);
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"AbsReplace-After: "
+yR2
+tree
+cH2
+xO1"\n"
+<<std::flush;DumpHashes(tree
+cH2;
+#endif
+goto
+NowWeAreMulGroup;}
+}
+yY3
+#define HANDLE_UNARY_CONST_FUNC(funcname) y23 funcname(lS nD
+case
+cLog:eW3(fp_log);if(e43
+cPow
+nQ
+pow=tQ;if(GetPositivityInfo(pow
+l8
+0))==IsAlways
+xA3
+pow
+xF1
+tree.lV
+if(GetEvennessInfo(pow
+l8
+1))==IsAlways
+xA3
+xG
+abs;abs
+c4
+cAbs);abs
+y7
+pow
+xN2
+abs
+eM1
+pow
+xF1
+pow.n41
+0,abs);tree.lV}
+i81
+e43
+cAbs
+nQ
+pow=tQ
+l8
+0);if(pow
+nF==cPow
+xA3
+xG
+abs;abs
+c4
+cAbs);abs
+y7
+pow
+xN2
+abs
+eM1
+pow
+xF1
+pow.n41
+0,abs);tree.lV}
+lD
+cAcosh:eW3(fp_acosh);lD
+cAsinh:eW3(fp_asinh);lD
+cAtanh:eW3(fp_atanh);lD
+cAcos:eW3(fp_acos);lD
+cAsin:eW3(fp_asin);lD
+cAtan:eW3(fp_atan);lD
+cCosh:eW3(fp_cosh);lD
+cSinh:eW3(fp_sinh);lD
+cTanh:eW3(fp_tanh);lD
+cSin:eW3(fp_sin);lD
+cCos:eW3(fp_cos);lD
+cTan:eW3(fp_tan);lD
+cCeil:if(n5
+eW3(fp_ceil);lD
+cTrunc:if(n5
+eW3(fp_trunc);lD
+cFloor:if(n5
+eW3(fp_floor);lD
+cInt:if(n5
+eW3(fp_int);lD
+cCbrt:eW3(fp_cbrt);lD
+cSqrt:eW3(fp_sqrt);lD
+cExp:eW3(fp_exp);lD
+cLog2:eW3(fp_log2);lD
+cLog10:eW3(fp_log10);lD
+cLog2by:if
+lJ
+fp_log2(lS)*c13
+cArg:eW3(fp_arg);lD
+cConj:eW3(fp_conj);lD
+cImag:eW3(fp_imag);lD
+cReal:eW3(fp_real);lD
+cPolar:if
+lJ
+fp_polar
+e42
+cMod:if
+lJ
+fp_mod
+e42
+cAtan2:{range
+yB
+p0
+tN
+p1=tO
+1));cD3
+fp_equal(lS,tD1))cI3
+p1
+t6&&(p1
+nV)<tD1
+nR
+fp_const_pi
+yB(nD
+if(p1
+eY&&p1
+e32>=tN2
+tD1
+nD}
+if
+lM1
+fp_equal(tM),tD1))cI3
+p0
+t6&&(p0
+nV)<tD1
+nR-fp_const_pihalf
+yB(nD
+if(p0
+eY&&p0
+e32>tD1
+nR
+fp_const_pihalf
+yB(nD}
+if
+lJ
+fp_atan2(lS,tM)nD
+if((p1
+eY&&p1
+e32>tD1))||(p1
+t6&&(p1
+nV)<fp_const_negativezero
+yB())nQ
+yG2;yG2
+c4
+cPow);yG2
+y7
+t32);yG2.yJ
+l62(-1)));yG2
+eM1
+xG
+yH2;yH2
+c4
+cMul);yH2
+y7
+tQ);yH2
+y7
+yG2);yH2
+eM1
+tree
+c4
+cAtan);tree.n41
+0,yH2)lP2
+1);i31
+cPow:{if(ConstantFolding_PowOperations(e82
+break
+cT1
+cDiv:cD3
+xP1
+yO2&&tM)!=tN2
+lS/c13
+cInv:cD3
+lS!=tN2
+l62(1)/lS);yV1
+cSub:if
+lJ
+lS-c13
+cNeg:y23-lS);yV1
+cRad:y23
+RadiansToDegrees(lS
+nD
+lD
+cDeg:y23
+DegreesToRadians(lS
+nD
+lD
+cSqr:y23
+lS*lS);yV1
+cExp2:eW3(fp_exp2);lD
+cRSqrt:y23
+l62(1)/fp_sqrt(lS
+nD
+lD
+cCot
+tK3
+fp_tan(n3
+cSec
+tK3
+fp_cos(n3
+cCsc
+tK3
+fp_sin(n3
+cHypot:if
+lJ
+fp_hypot
+e42
+cRDiv:case
+cRSub:case
+cDup:case
+cFetch:case
+cPopNMov:case
+cSinCos:case
+cSinhCosh:case
+cNop:case
+cJump:lD
+cPCall:case
+cFCall:yY3
+do_return:;
+#ifdef DEBUG_SUBSTITUTIONS
+std::cout<<"["
+<<(&yW3)<<"]Done ConstantFolding, result: "
+xY
+DumpHashes(tree);
+#endif
+}
+}
+#endif
+#ifdef FP_SUPPORT_OPTIMIZER
+tC{x73
+range
+yB::set_abs(nN
+bool
+has_negative=!min.known||min.val<l62();bool
+has_positive=!max.known||max.val>l62();bool
+crosses_axis=has_negative&&has_positive;rangehalf
+yB
+newmax;if(min
+iN2
+max.known)newmax.set(fp_max(tQ1,tS1);if(crosses_axis)min.set(l62());eN3
+min
+iN2
+max.known)min.set(fp_min(tQ1,tS1);i81
+min.known)min.set(tQ1);else
+min.set(tS1;}
+max=newmax;}
+x73
+range
+yB::set_neg(){std::swap(min,max);min.val=-min.val;max.val=-max.val;}
+yD
+bool
+IsLogicalTrueValue
+cY1
+range
+yB&p
+eZ2{if(nE
+IsIntType
+yB::nT3
+cI3
+p
+eY
+cF3>=l62(1
+t41;if(!abs&&p
+t6&&p
+nV<=l62(-1
+t41;}
+eN3
+p
+eY
+cF3>=l62(0.5
+t41;if(!abs&&p
+t6&&p
+nV<=l62(-0.5
+t41
+yC3
+e83
+yD
+bool
+IsLogicalFalseValue
+cY1
+range
+yB&p
+eZ2{if(nE
+IsIntType
+yB::nT3
+cI3
+abs)yD3
+t6
+yG1
+1);else
+yD3
+eY&&p
+t6
+cF3>l62(-1)yG1
+1);}
+eN3
+abs)yD3
+t6
+yG1
+0.5);else
+yD3
+eY&&p
+t6
+cF3>l62(-0.5)yG1
+0.5);}
+}
+}
+#endif
+#ifdef FP_SUPPORT_OPTIMIZER
+using
+iR2
+FUNCTIONPARSERTYPES;using
+tC;tC{yD
+range
+yB
+iO
+xB3)
+#ifdef DEBUG_SUBSTITUTIONS_extra_verbose
+{using
+iR2
+FUNCTIONPARSERTYPES;range
+yB
+tmp=CalculateResultBoundaries_do(tree)xO1"Estimated boundaries: "
+;if(tmp
+eY)std::cout<<tmp
+e32;else
+std::cout<<"-inf"
+xO1" .. "
+;if(tmp
+t6)std::cout<<tmp
+nV;else
+std::cout<<"+inf"
+xO1": "
+yR2
+tree)xO1
+std::endl
+eO
+tmp;}
+yD
+range
+yB
+xG::CalculateResultBoundaries_do
+cY1
+cV2
+#endif
+{iI
+y81(-fp_const_pihalf
+yB(),fp_const_pihalf
+yB());iI
+pi_limits(-fp_const_pi
+yB(),fp_const_pi
+yB());iI
+abs_pi_limits(tD1),fp_const_pi
+yB());iI
+plusminus1_limits(l62(-n23
+using
+iR2
+std;switch
+l83{case
+cImmed:nS
+tree.xE1,tree.xE1);case
+cAnd:case
+cAbsAnd:case
+cOr:case
+cAbsOr:case
+cNot:case
+c03:case
+cNotNot:case
+cAbsNotNot:case
+cEqual:case
+tP1:case
+cLess:case
+cLessOrEq:case
+cGreater:case
+cGreaterOrEq:{nS
+tD1),l62(1))cT1
+cAbs:lE
+m.set_abs(tR1
+cLog:lE
+lU3
+fp_log
+tP2
+fp_log
+tR1
+cLog2:lE
+lU3
+fp_log2
+tP2
+fp_log2
+tR1
+cLog10:lE
+lU3
+fp_log10
+tP2
+fp_log10
+tR1
+cAcosh:lE
+yI
+xT1
+cGreaterOrEq
+eZ1
+fp_acosh
+eR3
+cGreaterOrEq
+eZ1
+fp_acosh
+tR1
+cAsinh:lE
+yI
+set(fp_asinh
+tI2
+set(fp_asinh
+tR1
+cAtanh:lE
+yI
+n2-1),fp_atanh
+eR3
+cLess
+eZ1
+fp_atanh
+tR1
+cAcos:lE
+nS(m
+t6&&(m
+nV)<l62(1))?fp_acos(m
+nV):tD1),(eJ2&&cI2)>=l62(-1))?fp_acos
+cI2):fp_const_pi
+yB())cT1
+cAsin:lE
+yI
+n2-1),fp_asin,y81
+e32
+eR3
+cLess
+eZ1
+fp_asin,y81
+nV
+tR1
+cAtan:lE
+yI
+set(fp_atan,y81
+e32
+tI2
+set(fp_atan,y81
+nV
+tR1
+cAtan2:{cD3
+fp_equal(lS,tD1)))yS
+abs_pi_limits;}
+if
+lM1
+fp_equal(tM),tD1)))yS
+y81
+yC3
+pi_limits
+cT1
+cSin:lE
+bool
+nS1=!eJ2||!m
+t6||(m
+nV-yI
+val)>=(yG
+nS1)t8
+l62
+min=fp_mod
+cI2,yG
+min<tD1))min
+yQ
+l62
+max=fp_mod(m
+nV,yG
+max<tD1))max
+yQ
+if(max<min)max
+yQ
+bool
+xU1=(min<=fp_const_pihalf
+yB()&&max>=fp_const_pihalf
+yB());bool
+nD1=(min<=cI&&max>=cI);if(xU1&&nD1)t8
+if(nD1)nS
+l62(-1),yI2;if(xU1)nS
+yK2
+l62(1));nS
+yK2
+yI2
+cT1
+cCos:lE
+if(eJ2)yI
+val+=fp_const_pihalf
+yB();if(m
+t6)m
+nV+=fp_const_pihalf
+yB();bool
+nS1=!eJ2||!m
+t6||(m
+nV-yI
+val)>=(yG
+nS1)t8
+l62
+min=fp_mod
+cI2,yG
+min<tD1))min
+yQ
+l62
+max=fp_mod(m
+nV,yG
+max<tD1))max
+yQ
+if(max<min)max
+yQ
+bool
+xU1=(min<=fp_const_pihalf
+yB()&&max>=fp_const_pihalf
+yB());bool
+nD1=(min<=cI&&max>=cI);if(xU1&&nD1)t8
+if(nD1)nS
+l62(-1),yI2;if(xU1)nS
+yK2
+l62(1));nS
+yK2
+yI2
+cT1
+cTan:{nS)cT1
+cCeil:lE
+m
+eM
+cFloor:lE
+yJ2
+tR1
+cTrunc:lE
+yJ2);m
+eM
+cInt:lE
+yJ2);m
+eM
+cSinh:lE
+yI
+set(fp_sinh
+tI2
+set(fp_sinh
+tR1
+cTanh:lE
+yI
+set(fp_tanh,plusminus1_limits.min
+tI2
+set(fp_tanh,plusminus1_limits.max
+tR1
+cCosh:lE
+if(eJ2
+cI3
+m
+t6){if
+cI2
+cW1&&m
+nV
+cW1){yI
+val=e1}
+i81
+cI2)<tD1)&&m
+nV
+cW1){l62
+tmp=e1
+if(tmp>m
+nV)m
+nV=tmp;yI
+val=l62(1);}
+else{yI
+val=e1
+std::swap
+cI2,m
+nV);}
+}
+else{if
+cI2
+cW1){m.cJ
+yI
+val=fp_cosh
+cI2);}
+else{m.cJ
+yI
+val=l62(1);}
+}
+}
+else{eJ2=true;yI
+val=l62(1);if(m
+t6){yI
+val=fp_cosh(m
+nV);m.cJ}
+else
+m.cJ}
+return
+m
+cT1
+cIf:case
+cAbsIf:{range
+yB
+res1=tO
+1));range
+yB
+res2=tO
+2));if(!res2
+eY)res1
+eY
+e23
+i81
+res1
+eY&&(res2
+e32)<res1
+e32)res1
+e32=res2
+e32;if(!res2
+t6)res1.cJ
+i81
+res1
+t6&&(res2
+nV)>res1
+nV)res1
+nV=res2
+nV
+eO
+res1
+cT1
+cMin:{bool
+iJ
+e23
+bool
+iK
+e23
+range
+lV3;x8
+m=tO
+c23
+eJ2)iJ
+e33
+eY||cI2)<lW3)lW3=yI
+val;if(!m
+t6)iK
+e33
+t6||(m
+nV)<lX3)lX3=m
+nV;}
+if(iJ)lY3
+iK)tX2
+cJ
+return
+lZ3
+cMax:{bool
+iJ
+e23
+bool
+iK
+e23
+range
+lV3;x8
+m=tO
+c23
+eJ2)iJ
+e33
+eY||yI
+val>lW3)lW3=yI
+val;if(!m
+t6)iK
+e33
+t6||m
+nV>lX3)lX3=m
+nV;}
+if(iJ)lY3
+iK)tX2
+cJ
+return
+lZ3
+cAdd:{range
+lV3(tD1),tD1));x8
+item=tO
+a));if(item
+eY)lW3+=item
+e32;else
+lY3
+item
+t6)lX3+=item
+nV;else
+tX2
+cJ
+if(!n03&&!n13)yY3
+if(n03&&n13&&lW3>lX3)std::swap
+tQ2,lX3)eO
+lZ3
+cMul:{cP2
+Value{enum
+nE3{tR2,iM1,tS2}
+;nE3
+eZ;l62
+value;Value(nE3
+t):eZ(t),value(0){}
+Value(l62
+v):eZ(tR2),value(v){}
+bool
+cJ2
+yK1
+eZ==iM1||(eZ==tR2&&value<tD1)n33
+eD1*=cY1
+Value&rhs
+cI3
+eZ==tR2&&rhs.eZ==tR2)value*=rhs.value;else
+eZ=(cJ2)!=rhs.cJ2)?iM1:tS2);}
+bool
+eD1<cY1
+Value&rhs
+yK1(eZ==iM1&&rhs.eZ!=iM1)||(eZ==tR2&&(rhs.eZ==tS2||(rhs.eZ==tR2&&value<rhs.value)));}
+}
+;cP2
+y91{Value
+yL2,yM2;y91():yL2(Value::tS2),yM2(Value::iM1){}
+void
+x22
+Value
+c33,const
+Value&value2){c33*=value2;if(c33<yL2)yL2=c33;if(yM2<c33)yM2=c33;}
+}
+;range
+lV3(l62(n23
+x8
+item=tO
+c23
+item
+eY&&!item
+t6)nS);Value
+nF3=n03?Value
+tQ2):t01
+iM1);Value
+nG3=n13?Value(lX3):t01
+tS2);Value
+nH3=item
+eY?Value(item
+e32):t01
+iM1);Value
+nI3=item
+t6?Value(item
+nV):t01
+tS2);y91
+range;range.x22
+nF3,nH3
+e52
+nF3,nI3
+e52
+nG3,nH3
+e52
+nG3,nI3);if(range.yL2.eZ==Value::tR2)lW3=range.yL2.value;else
+lY3
+range.yM2.eZ==Value::tR2)lX3=range.yM2.value;else
+tX2
+cJ
+if(!n03&&!n13)yY3
+if(n03&&n13&&lW3>lX3)std::swap
+tQ2,lX3)eO
+lZ3
+cMod:{range
+yB
+x
+tN
+y=tO
+1));if(y
+t6
+cI3
+y
+nV
+cW1
+cI3!x
+eY||(x
+e32)<tD1))nS-y
+nV,y
+nV);else
+nS
+tD1),y
+nV);}
+eN3!x
+t6||(x
+nV)cW1)nS
+y
+nV,-y
+nV);else
+nS
+y
+nV,fp_const_negativezero
+yB());}
+}
+else
+nS)cT1
+cPow:{if
+lM1
+tM)==tD1)){nS
+l62(n23}
+cD3
+lS==tD1)){nS
+tD1),tD1));}
+cD3
+fp_equal(lS
+n53
+nS
+l62(n23}
+if
+lM1
+tM)>tD1)&&GetEvennessInfo(t32)==IsAlways){l62
+cY2
+tM);range
+yB
+tmp
+tN
+nT3;n03=true;lW3=0;if(tmp
+eY&&tmp
+e32
+cW1)lW3
+xV3
+tmp
+e32,x32;i81
+tmp
+t6&&tmp
+nV<=tD1))lW3
+xV3
+tmp
+nV,x32;tX2
+cJ
+if(tmp
+eY&&tmp
+t6){n13=true;lX3=fp_max(fp_abs(tmp
+e32),fp_abs(tmp
+nV));lX3
+xV3
+lX3,x32
+yC3
+nT3;}
+range
+yB
+p0
+tN
+p1=tO
+1
+n52
+p0_positivity=(p0
+eY&&(p0
+e32)cW1)?IsAlways:(p0
+t6&&(p0
+nV)<tD1)?iO2
+Unknown);TriTruthValue
+cK2=GetEvennessInfo(xP1
+1
+n52
+t3=Unknown;switch(p0_positivity)i71
+t3=IsAlways;lD
+iO2{t3=cK2;yY3
+y13
+switch(cK2)i71
+t3=IsAlways;lD
+iO2
+lD
+Unknown:{if
+lM1!isInteger
+tL&&tM)cW1){t3=IsAlways;}
+yN3
+yX3(t3)i71{if((p1
+t6&&p1
+nV<0)||(p1
+eY&&p1
+e32<0)){nS);}
+l62
+min=tD1);if(p0
+eY&&p1
+eY){min
+xV3
+p0
+e32,p1
+e32);if(p0
+e32<tD1)&&(!p1
+t6||p1
+nV
+cW1)&&min
+cW1)min=tD1);}
+if(p0
+eY&&p0
+e32
+cW1&&p0
+t6&&p1
+t6){l62
+max
+xV3
+p0
+nV,p1
+nV);if(min>max)std::swap(min,max);nS
+min,max);}
+nS
+min,false)cT1
+iO2{nS
+false,fp_const_negativezero
+yB());}
+y13{yY3
+i31
+cNeg:lE
+m.set_neg(tR1
+cSub:{nA
+cNeg
+y53
+1
+nY3
+cAdd);nZ3;tmp
+c43
+eO
+lI
+cInv:{nB-1
+cE3
+cDiv:{nA
+cInv
+y53
+1
+nY3
+xV1
+c43
+eO
+lI
+cRad:{t21
+xV1.yJ
+fp_const_rad_to_deg
+yB(cE3
+cDeg:{t21
+xV1.yJ
+fp_const_deg_to_rad
+yB(cE3
+cSqr:{nB
+2
+cE3
+cExp:{t21
+cPow);tmp.yJ
+fp_const_e
+yB()));nZ3
+eO
+lI
+cExp2:{t21
+cPow);tmp
+eB1
+nZ3
+eO
+lI
+cCbrt:lE
+yI
+set(fp_cbrt
+tI2
+set(fp_cbrt
+tR1
+cSqrt:lE
+if(eJ2)yI
+val=cI2)<tD1)?0:fp_sqrt
+cI2);if(m
+t6)m
+nV=(m
+nV)<tD1)?0:fp_sqrt(m
+nV
+tR1
+cRSqrt:{nB-0.5
+cE3
+cHypot:{xG
+xsqr,ysqr,add,sqrt;xsqr.n7
+0));xsqr
+eB1
+ysqr.n7
+1));ysqr
+eB1
+xsqr
+c4
+cPow);ysqr
+c4
+cPow);add
+y7
+xsqr);add
+y7
+ysqr);add
+c4
+cAdd);sqrt
+y7
+add);sqrt
+c4
+cSqrt)eO
+iO
+sqrt)cT1
+cLog2by:{nA
+cLog2
+y53
+0
+nY3
+cMul);tmp
+c43;tmp.n7
+1))eO
+lI
+cCot:{nA
+cTan
+x4
+lI
+cSec:{nA
+cCos
+x4
+lI
+cCsc:{nA
+cSin
+x4
+iO
+tmp);}
+lD
+cRDiv:case
+cRSub:case
+cDup:case
+cFetch:case
+cPopNMov:case
+cSinCos:case
+cSinhCosh:case
+cNop:case
+cJump:case
+iE2:lD
+cArg:case
+cConj:case
+cImag:case
+cReal:case
+cPolar:lD
+cPCall:lD
+cFCall:yY3
+nS);}
+yD
+TriTruthValue
+GetIntegerInfo
+cY1
+cV2{switch
+l83{case
+cImmed:return
+t12
+tree.xE1)?IsAlways:xL3;case
+cFloor:case
+cCeil:case
+cTrunc:case
+cInt:return
+IsAlways;case
+cAnd:case
+cOr:case
+cNot:case
+cNotNot:case
+cEqual:case
+tP1:case
+cLess:case
+cLessOrEq:case
+cGreater:case
+cGreaterOrEq:return
+IsAlways;case
+cIf:{TriTruthValue
+a=GetIntegerInfo(xP1
+1
+n52
+b=GetIntegerInfo(cC3);if(a==b)return
+a
+eO
+Unknown
+cT1
+cAdd:case
+cMul:{for
+c7
+if(GetIntegerInfo
+tN3)!=IsAlways)return
+Unknown
+eO
+IsAlways;}
+y13
+break
+yC3
+Unknown;}
+yD
+bool
+IsLogicalValue
+cY1
+cV2{switch
+l83{case
+cImmed:return
+fp_equal(tree.xE1,tD1))||fp_equal(tree.xE1,l62(1));case
+cAnd:case
+cOr:case
+cNot:case
+cNotNot:case
+cAbsAnd:case
+cAbsOr:case
+c03:case
+cAbsNotNot:case
+cEqual:case
+tP1:case
+cLess:case
+cLessOrEq:case
+cGreater:case
+cGreaterOrEq:x0
+cMul:{for
+c7
+if(!IsLogicalValue
+tN3)c5
+return
+true
+cT1
+cIf:case
+cAbsIf:yS
+IsLogicalValue(t32)nK1
+cC3);}
+y13
+break
+yC3
+e83}
+#endif
+#ifdef FP_SUPPORT_OPTIMIZER
+using
+iR2
+FUNCTIONPARSERTYPES;
+#if defined(__x86_64) || !defined(FP_SUPPORT_CPLUSPLUS11_MATH_FUNCS)
+# define CBRT_IS_SLOW
+#endif
+#if defined(DEBUG_POWI) || defined(DEBUG_SUBSTITUTIONS)
+#include <cstdio>
+#endif
+iR2
+x51{extern
+const
+unsigned
+char
+powi_table[256];}
+iR2{using
+tC;yD
+bool
+IsOptimizableUsingPowi(long
+immed,long
+penalty=0){x51
+yZ3
+synth;synth.PushVar(iE2);size_t
+bytecodesize_backup
+eJ3
+GetByteCodeSize();x51::nQ1
+immed,x51::tH1
+yB::MulSequence,synth);size_t
+bytecode_grow_amount
+eJ3
+GetByteCodeSize()-bytecodesize_backup
+eO
+bytecode_grow_amount<size_t(MAX_POWI_BYTECODE_LENGTH-penalty);}
+x73
+ChangeIntoRootChain(xG&tree,bool
+iP2,long
+tT2,long
+tU2){while(tU2>0
+nP2
+cCbrt);nQ2
+tmp
+eM1
+tree.tV2--tU2;}
+while(tT2>0
+nP2
+cSqrt);if(iP2){tmp
+c4
+cRSqrt);iP2
+e23}
+nQ2
+tmp
+eM1
+tree.tV2--tT2;}
+if(iP2
+nP2
+cInv);nQ2
+tree.tV2}
+}
+yD
+cP2
+RootPowerTable{static
+const
+l62
+RootPowers[(1+4)*(1+3)];}
+;yD
+const
+l62
+tF(1+4)*(1+3)]={l62(1)lT
+eQ3
+eQ3
+2*eQ3
+2*2*2)lT
+3)lT
+3*2)lT
+3*2*2)lT
+3*2*2*2)lT
+3*2*2*2*2)lT
+3*3
+i32
+2
+i32
+2*2
+i32
+2*2*2
+i32
+2*2*2*2
+i32
+3
+i32
+3*2
+i32
+3*2*2
+i32
+3*2*2*2
+i32
+3*2*2*2*2)}
+;cP2
+PowiResolver{static
+const
+unsigned
+MaxSep=4;static
+nK3
+MaxOp=5
+tO3
+int
+c53
+tO3
+long
+nS3
+tO3
+long
+tH;cP2
+yN2{yN2():n_int_sqrt(0),n_int_cbrt(0),sep_list(),lU1(0){}
+int
+n_int_sqrt;int
+n_int_cbrt;int
+tG1
+MaxSep];tH
+lU1;}
+;yD
+static
+yN2
+CreatePowiResult(l62
+x32{yN2
+nT3;c53
+tG=FindIntegerFactor(x32;if(tG==0){
+#ifdef DEBUG_POWI
+tW2"no factor found for %Lg\n"
+,e21
+x32;
+#endif
+return
+nT3;}
+cG3=xW1
+nU3,tG);nS3
+eP2=EvaluateFactorCost(tG,0,0,0)+cH
+cG3);int
+eS3=0;int
+eT3=0;int
+nJ3=0;
+#ifdef DEBUG_POWI
+tW2"orig = %Lg\n"
+,e21
+x32;tW2"plain factor = "
+tA3"%ld\n"
+,(int)tG,(long)eP2);
+#endif
+for
+nD2
+n_s=0;n_s<MaxSep;++n_s){int
+xJ=0;nS3
+yA1=eP2;c53
+yI1=tG;for(int
+s=1;s<MaxOp*4;++s){
+#ifdef CBRT_IS_SLOW
+if(s>=MaxOp)break;
+#endif
+int
+n_sqrt=s%MaxOp;int
+n_cbrt=s/MaxOp;if(n_sqrt+n_cbrt>4)y41
+l62
+lD1=nU3;lD1-=tF
+s];tT1=FindIntegerFactor(lD1);if(xH2!=0){tH
+xO=xW1
+lD1,xH2);nS3
+cost=EvaluateFactorCost(xH2,eS3+n_sqrt,eT3+n_cbrt,nJ3+1)+cH
+xO);
+#ifdef DEBUG_POWI
+tW2"Candidate sep %u (%d*sqrt %d*cbrt)factor = "
+tA3"%ld (for %Lg to %ld)\n"
+,s,n_sqrt,n_cbrt,xH2,(long)cost,e21
+lD1,(long)xO);
+#endif
+if(cost<yA1){xJ=s;yI1=xH2;yA1=cost;}
+}
+}
+if(!xJ)break;
+#ifdef DEBUG_POWI
+tW2"CHOSEN sep %u (%d*sqrt %d*cbrt)factor = "
+tA3"%ld, exponent %Lg->%Lg\n"
+,xJ,xJ%MaxOp,xJ/MaxOp,yI1,yA1,e21(x32,e21(nU3-tF
+xJ]));
+#endif
+tX2
+tG1
+n_s]=xJ
+t11-=tF
+xJ];eS3+=xJ%MaxOp;eT3+=xJ/MaxOp;eP2=yA1;tG=yI1;nJ3+=1;}
+cG3=xW1
+nU3,tG);
+#ifdef DEBUG_POWI
+tW2"resulting exponent is %ld (from exponent=%Lg, best_factor=%Lg)\n"
+,cG3,e21
+nU3,e21
+tG);
+#endif
+while(tG%2==0){++tX2
+n_int_sqrt;tG/=2;}
+while(tG%3==0){++tX2
+n_int_cbrt;tG/=3
+yC3
+nT3;}
+private:static
+nS3
+cH
+tH
+xO){static
+std::map
+cL2
+iC;if(xO<0){nS3
+cost=22
+eO
+cost+cH-xO);}
+std::map
+cL2::xR3
+i=iC.xI2
+xO);if(i!=iC.cH1
+xO)return
+i
+cW2;std::pair
+cL2
+nT3(xO,0.0);nS3&cost=tX2
+second;while(xO>1){int
+xH2=0;if(xO<256){xH2=x51::powi_table[xO];if(xH2&128)xH2&=127;else
+xH2=0;if(xH2&64)xH2=-(xH2&63)-1;}
+if(xH2){cost+=cH
+xH2);xO/=xH2;y41}
+if(!(xO&1)){xO/=2;cost+=6;}
+else{cost+=7;xO-=1;}
+}
+iC.xN3,nT3)eO
+cost;}
+yD
+static
+tH
+xW1
+yB1,tT1)yS
+makeLongInteger(value*l62(xH2));}
+yD
+static
+bool
+yC1
+yB1,tT1){l62
+v=value*l62(xH2)eO
+isLongInteger(v);}
+yD
+static
+c53
+FindIntegerFactor(yB1){tT1=(2*2*2*2);
+#ifdef CBRT_IS_SLOW
+#else
+xH2*=(3*3*3);
+#endif
+c53
+nT3=0;if(yC1
+value,xH2)){nT3=xH2;while((xH2%2)==0&&yC1
+value,xH2/2))nT3=xH2/=2;while((xH2%3)==0&&yC1
+value,xH2/3))nT3=xH2/=3;}
+#ifdef CBRT_IS_SLOW
+if(nT3==0
+cI3
+yC1
+value,3
+tJ2
+3;}
+#endif
+return
+nT3;}
+static
+int
+EvaluateFactorCost(int
+xH2,int
+s,int
+c,int
+nmuls){nK3
+nL3=6;
+#ifdef CBRT_IS_SLOW
+nK3
+eQ2=25;
+#else
+nK3
+eQ2=8;
+#endif
+int
+nT3=s*nL3+c*eQ2;while(xH2%2==0){xH2/=2;nT3+=nL3;}
+while(xH2%3==0){xH2/=3;nT3+=eQ2;}
+nT3+=nmuls
+eO
+nT3;}
+}
+;}
+tC{yD
+bool
+xG::RecreateInversionsAndNegations(bool
+prefer_base2){bool
+changed
+e23
+n72
+0;a<x31++a)if(lP1.RecreateInversionsAndNegations(prefer_base2))nS2
+if(changed){exit_changed:Mark_Incompletely_Hashed()cT2
+switch(l42{case
+cMul:{nX2
+lK2;xG
+lL2,c81;if(true){bool
+nE1
+e23
+l62
+nR2=0;n72
+x31
+a
+nX
+y33
+0)y43
+tU
+yO2){nE1=true;nR2=tU
+1).xE1;yN3
+if(nE1){l62
+immeds=1.0;n72
+x31
+a
+nX
+yP2)){immeds*=powgroup.xE1;e71}
+n72
+x31
+a-->0;nQ&powgroup=lP1;if(powgroup
+y33
+0)y43
+tU
+yO2
+nQ&log2=tU
+0);log2.l41
+log2
+c4
+nM3
+log2.yJ
+fp_pow(immeds,l62(1)/nR2)));log2
+eM1
+yN3}
+}
+n72
+x31
+a
+nX
+y33
+yO2){iT1
+exp_param=tU
+1);l62
+cY2
+exp_param.xE1;if(cJ1,l62(-1))){l41
+lK2
+yS2
+lP1
+xN2
+e71
+i81
+nU3<tD1)&&t12
+x32
+nQ
+iL;iL
+c4
+cPow);iL
+cM
+tU
+0));iL.yJ-x32);iL
+eM1
+lK2
+yS2
+iL);l41
+e71}
+i81
+powgroup
+y43!lL2.n12){lL2=tU
+0);l41
+e71
+i81
+powgroup
+nF==cLog2by&&!c81.n12){c81=powgroup;l41
+e71}
+if(!lK2
+yU3){nS2
+xG
+i91;i91
+c4
+cMul);i91
+iY1
+lK2);i91
+eM1
+xG
+xX1
+cMul);xY1
+SetParamsMove(t4
+if(xY1
+IsImmed()&&fp_equal(xY1
+xE1
+n53
+lM2
+cInv);eE
+i91);}
+eN3
+xY1
+xT2>=i91.xT2){lM2
+cDiv)c91
+eE
+i91);}
+else{lM2
+cRDiv);eE
+i91)c91}
+}
+}
+if(lL2.n12
+nQ
+xX1
+l42;xY1
+SetParamsMove(t4
+while(xY1
+RecreateInversionsAndNegations(prefer_base2))xY1
+FixIncompleteHashes();lM2
+nM3
+eE
+lL2)c91
+nS2}
+if(c81.n12
+nQ
+xX1
+cMul);i82
+y7
+c81
+l8
+1));xY1
+AddParamsMove(t4
+while(xY1
+RecreateInversionsAndNegations(prefer_base2))xY1
+FixIncompleteHashes();DelParams();lM2
+nM3
+eE
+c81
+l8
+0))c91
+nS2
+i31
+cAdd:{nX2
+tY2;n72
+n93
+c63
+cMul){lN2
+xZ1:;xG&i82
+c73
+x62
+xY1
+x31
+b-->0;cI3
+i82
+l8
+b).lK1
+xH2=i82
+l8
+b).xE1;if(fp_equal(xH2
+xV
+xZ1;}
+xY1
+l41
+xY1
+DelParam(b
+yT2
+i81
+fp_equal(xH2,l62(-2)))eG
+xZ1;}
+xY1
+l41
+xY1
+DelParam(b);xY1
+yJ
+l62(2))yT2}
+}
+if(t9){xY1
+tI
+i82);e71}
+i81
+c63
+cDiv&&!IsIntType
+yB::nT3){lN2
+y01:;xG&i91
+c73
+if(i91
+l8
+0).lO2
+fp_equal(i91
+l8
+0).xE1
+xV
+y01;}
+i91.l41
+i91.DelParam(0);i91
+c4
+cInv
+yT2}
+if(t9)eG
+y01;}
+i91.tI
+i91);e71}
+i81
+c63
+cRDiv&&!IsIntType
+yB::nT3){lN2
+nZ1:;xG&i91
+c73
+if(i91
+l8
+1).lO2
+fp_equal(i91
+l8
+1).xE1
+xV
+nZ1;}
+i91.l41
+i91.DelParam(1);i91
+c4
+cInv
+yT2}
+if(t9)eG
+nZ1;}
+i91.tI
+i91);e71}
+if(!tY2
+yU3){
+#ifdef DEBUG_SUBSTITUTIONS
+tW2"Will make a Sub conversion in:\n"
+);fflush(stdout);iQ
+#endif
+xG
+t71;t71
+c4
+cAdd);t71
+iY1
+tY2);t71
+eM1
+xG
+cD1;cD1
+c4
+cAdd);cD1
+iY1
+iP1));cD1
+eM1
+if(cD1
+yP2)&&fp_equal(cD1.xE1,tD1))){lM2
+cNeg
+nN3);}
+eN3
+cD1.xT2==1){lM2
+cRSub
+nN3);eE
+cD1);}
+i81
+t71
+nF==cAdd){lM2
+cSub);eE
+cD1
+nN3
+xN2
+n72
+1;a<t71.x31++a
+nQ
+eR2;eR2
+c4
+cSub);eR2
+iY1
+iP1));eR2.lF2
+eE
+eR2
+nN3
+lS3}
+}
+else{lM2
+cSub);eE
+cD1
+nN3);}
+}
+#ifdef DEBUG_SUBSTITUTIONS
+tW2"After Sub conversion:\n"
+);fflush(stdout);iQ
+#endif
+i31
+cPow:{iT1
+p0
+nT2
+0);iT1
+p1
+nT2
+1);if(p1.lO2
+p1.xE1!=tD1)&&!t12
+p1.xE1)){eJ
+yN2
+r=eJ
+CreatePowiResult(fp_abs(p1.xE1));if(r.lU1!=0){bool
+iN1
+e23
+if(p1.xE1<tD1)&&r.tG1
+0]==0&&r.n_int_sqrt>0){iN1=true;}
+#ifdef DEBUG_POWI
+tW2"Will resolve powi %Lg as powi(chain(%d,%d),%ld)"
+,e21
+fp_abs(p1.xE1),r.n_int_sqrt,r.n_int_cbrt,r.lU1);for
+nD2
+n=0;n<eJ
+MaxSep;++n
+cI3
+r.tG1
+n]==0)break;int
+n_sqrt=r.tG1
+n]%eJ
+MaxOp;int
+n_cbrt=r.tG1
+n]/eJ
+MaxOp;tW2"*chain(%d,%d)"
+,n_sqrt,n_cbrt);}
+tW2"\n"
+);
+#endif
+xG
+cM2
+nT2
+0);xG
+yU2=cM2;yU2.l41
+ChangeIntoRootChain(yU2,iN1,r.n_int_sqrt,r.n_int_cbrt);yU2
+eM1
+xG
+pow;if(r.lU1!=1){pow
+c4
+cPow);pow
+y7
+yU2);pow.yJ
+l62(r.lU1)));}
+else
+pow.swap(yU2);xG
+mul;mul
+c4
+cMul);mul
+y7
+pow);for
+nD2
+n=0;n<eJ
+MaxSep;++n
+cI3
+r.tG1
+n]==0)break;int
+n_sqrt=r.tG1
+n]%eJ
+MaxOp;int
+n_cbrt=r.tG1
+n]/eJ
+MaxOp;xG
+eS2=cM2;eS2.l41
+ChangeIntoRootChain(eS2,false,n_sqrt,n_cbrt);eS2
+eM1
+mul
+y7
+eS2);}
+if(p1.xE1<tD1)&&!iN1){mul
+eM1
+lM2
+cInv);n41
+0,mul);DelParam(1);}
+else{lM2
+cMul);SetParamsMove(mul.iP1));}
+#ifdef DEBUG_POWI
+iQ
+#endif
+nS2
+yN3}
+if(GetOpcode()==cPow&&(!p1
+yP2)||!isLongInteger(p1.xE1)||!IsOptimizableUsingPowi
+yB(makeLongInteger(p1.xE1)))cI3
+p0
+yP2)&&p0.xE1>l62(0.0)cI3
+prefer_base2){l62
+yV2=fp_log2(p0.xE1);if(fp_equal(yV2
+n53
+DelParam(0);}
+else{lX
+cL1
+yV2))t11
+cM
+p1)t11.Rehash(x41}
+lM2
+cExp2);nS2}
+else{l62
+yV2=fp_log(p0.xE1);if(fp_equal(yV2
+n53
+DelParam(0);}
+else{lX
+cL1
+yV2))t11
+cM
+p1)t11.Rehash(x41}
+lM2
+cExp);nS2}
+}
+i81
+GetPositivityInfo(p0)==IsAlways
+cI3
+prefer_base2
+nQ
+log;log
+c4
+cLog2);log
+cM
+p0);log
+eM1
+lX
+p1)t11
+y7
+log)t11
+eM1
+lM2
+cExp2
+x41
+nS2}
+else{xG
+log;log
+c4
+cLog);log
+cM
+p0);log
+eM1
+lX
+p1)t11
+y7
+log)t11
+eM1
+lM2
+cExp
+x41
+nS2}
+}
+i31
+cDiv:{if(GetParam(0)yP2)&&fp_equal(GetParam(0).xE1
+n53
+lM2
+cInv);DelParam(0);}
+yY3
+y13
+yY3
+if(changed)goto
+exit_changed
+eO
+changed;}
+}
+#endif
+#ifdef FP_SUPPORT_OPTIMIZER
+using
+iR2
+FUNCTIONPARSERTYPES;iR2{using
+tC;class
+cJ3{size_t
+nF1;size_t
+eK;size_t
+eL;size_t
+lE1;size_t
+tA;size_t
+tB;size_t
+n01;cV3
+cJ3():nF1(0),eK(0),eL(0),lE1(0),tA(0),tB(0),n01(0){}
+void
+AddFrom(OPCODE
+op){nF1+=1;if(op==cCos)++eK;if(op==cSin)++eL;if(op==cSec)++eK;if(op==cCsc)++eL;if(op==cTan)++lE1;if(op==cCot)++lE1;if(op==cSinh)++tB;if(op==cCosh)++tA;if(op==cTanh)++n01;}
+size_t
+GetCSEscore()const{size_t
+nT3=nF1
+eO
+nT3;}
+int
+NeedsSinCos()const{bool
+y11=(nF1==(eK+eL+lE1));if((lE1&&(eL||eK))||(eL&&eK)cI3
+y11)return
+1
+eO
+2
+yC3
+0;}
+int
+NeedsSinhCosh()const{bool
+y11=(nF1==(tA+tB+n01));if((n01&&(tB||tA))||(tB&&tA)cI3
+y11)return
+1
+eO
+2
+yC3
+0;}
+size_t
+MinimumDepth()const{size_t
+n_sincos=std::min(eK,eL);size_t
+n_sinhcosh=std::min(tA,tB);if(n_sincos==0&&n_sinhcosh==0)return
+2
+eO
+1;}
+}
+;x13
+TreeCountType:public
+std::multimap<fphash_t,std::pair<cJ3,xG> >{}
+;x73
+FindTreeCounts(t31&lQ2,xB3,OPCODE
+nU2,bool
+skip_root=false){e2
+i=lQ2.xI2
+xC3);if(!skip_root){bool
+found
+e23
+for(;i!=lQ2.cH1
+xC3;++i
+cI3
+tree
+xI
+i
+cW2.second)){i
+cW2
+y93
+AddFrom(nU2);found=true;yN3
+if(!found){cJ3
+count;count.AddFrom(nU2);lQ2.xN3,std::make_pair(xC3,std::make_pair(count,tree)));}
+}
+n72
+0
+tH2
+FindTreeCounts(lQ2,tJ3
+tree
+nF);}
+cP2
+yX{bool
+BalanceGood;bool
+FoundChild;}
+;yD
+yX
+lF1
+iT1
+root,iT1
+child
+cI3
+root
+xI
+child)){yX
+nT3={true,true}
+eO
+nT3;}
+yX
+nT3={true,false}
+;if(root
+nF==cIf||root
+nF==e63{yX
+cond=lF1
+root
+l8
+0
+x03
+yX
+y2=lF1
+root
+l8
+1
+x03
+yX
+y6=lF1
+root
+l8
+2
+x03
+if
+lF3||y2
+yY||y6
+yY){nT3
+yY=true;}
+nT3
+eH=((y2
+yY==y6
+yY)||lF3
+cN2&&(cond
+eH||(y2
+yY&&y6
+yY))&&(y2
+eH||lF3
+cN2&&(y6
+eH||lF3
+cN2;}
+else{bool
+tU1
+e23
+bool
+nG1
+e23
+x62
+root.GetParamCount(),a=0;a<b;++a){yX
+tmp=lF1
+root
+l8
+a
+x03
+if(tmp
+yY)nT3
+yY=true;if(tmp
+eH==false)tU1=true;i81
+tmp
+yY)nG1=true;}
+if(tU1&&!nG1)nT3
+eH=false
+yC3
+nT3;}
+yD
+bool
+n83
+iX2
+eU3
+xB3,const
+x51
+yZ3&synth,const
+t31&lQ2){x62
+t7,a=0;a<b;++a){iT1
+leaf=xP1
+a);e2
+synth_it;xL2
+t31::const_iterator
+i=lQ2.xQ3
+i!=lQ2.end();++i
+cI3
+i->first!=leaf.GetHash())y41
+const
+cJ3&occ
+n22
+first;size_t
+score=occ.GetCSEscore();iT1
+candidate
+n22
+second;lS2
+candidate))y41
+if(leaf.xT2<occ.MinimumDepth())y41
+if(score<2)y41
+if(lF1
+eU3
+leaf)eH==false)continue
+cT2
+if(n83(eU3
+leaf,synth,lQ2
+t41
+yC3
+e83
+yD
+bool
+lR2
+iX2
+xO3,iT1
+expr){yE
+xO3
+l8
+a)xI
+expr
+t41;yE
+lR2(xO3
+l8
+a),expr
+t41
+eO
+e83
+yD
+bool
+GoodMomentForCSE
+iX2
+xO3,iT1
+expr
+cI3
+xO3
+nF==cIf)return
+true;yE
+xO3
+l8
+a)xI
+expr
+t41;size_t
+tZ2=0;yE
+lR2(xO3
+l8
+a),expr))++tZ2
+eO
+tZ2!=1;}
+}
+tC{yD
+size_t
+xG::SynthCommonSubExpressions(x51::yM1
+const{if(GetParamCount()==0)return
+0;size_t
+stacktop_before
+eJ3
+GetStackTop();t31
+lQ2;FindTreeCounts(lQ2,*this,GetOpcode(),true);for(;;){size_t
+yW2=0;
+#ifdef DEBUG_SUBSTITUTIONS_CSE
+std::cout<<"Finding a CSE candidate, root is:"
+<<std::endl;DumpHashes(*this);
+#endif
+e2
+cs_it(lQ2.end());for(e2
+j=lQ2.xQ3
+j!=lQ2.end();){e2
+i(j++);const
+cJ3&occ
+n22
+first;size_t
+score=occ.GetCSEscore();xB3
+n22
+second;
+#ifdef DEBUG_SUBSTITUTIONS_CSE
+std::cout<<"Score "
+<<score<<":\n"
+<<std::flush;DumpTreeWithIndent(tree);
+#endif
+lS2
+tree))xS
+if(tree.xT2<occ.MinimumDepth())xS
+if(score<2)xS
+if(lF1*this,tree)eH==false)xS
+if(n83(*this,tree,synth,lQ2)){y41}
+if(!GoodMomentForCSE(*this,tree))xS
+score*=tree.xT2;if(score>yW2){yW2=score;cs_it=i;}
+}
+if(yW2<=0){
+#ifdef DEBUG_SUBSTITUTIONS_CSE
+std::cout<<"No more CSE candidates.\n"
+<<std::flush;
+#endif
+yY3
+xB3=cs_it
+cW2.second;
+#ifdef DEBUG_SUBSTITUTIONS_CSE
+std::cout<<tF3"Common Subexpression:"
+;DumpTree
+yB(tree)xO1
+std::endl;
+#endif
+#if 0
+int
+lV1=occ.NeedsSinCos();int
+i4=occ.NeedsSinhCosh();xG
+i02,i12,yX2,yY2;if(lV1){i02
+eT2
+i02
+c4
+cSin);i02
+eM1
+i12
+eT2
+i12
+c4
+cCos);i12
+eM1
+lS2
+i02)||synth.Find(i12)cI3
+lV1==2){t61
+y41}
+lV1=0;}
+}
+if(i4){yX2
+eT2
+yX2
+c4
+cSinh);yX2
+eM1
+yY2
+eT2
+yY2
+c4
+cCosh);yY2
+eM1
+lS2
+yX2)||synth.Find(yY2)cI3
+i4==2){t61
+y41}
+i4=0;}
+}
+#endif
+tree.SynthesizeByteCode(synth,false);t61
+#ifdef DEBUG_SUBSTITUTIONS_CSE
+synth.template
+Dump<0>()xO1"Done with Common Subexpression:"
+;DumpTree
+yB(tree)xO1
+std::endl;
+#endif
+#if 0
+if(lV1
+cI3
+lV1==2||i4){synth.eC1}
+n42
+cSinCos,1,2)cZ1
+i02,1)cZ1
+i12,0);}
+if(i4
+cI3
+lV1)synth.eC1
+if(i4==2){synth.eC1}
+n42
+cSinhCosh,1,2)cZ1
+yX2,1)cZ1
+yY2,0);}
+#endif
+}
+return
+synth.xH
+stacktop_before;}
+}
+#endif
+#ifdef FP_SUPPORT_OPTIMIZER
+yD
+lI1
+yB::i22{using
+tC;l41
+xG
+tree;tree.GenerateFrom(*mData);FPoptimizer_Optimize::ApplyGrammars(tree)e72
+unsigned>c83;std::vector
+yB
+immed;size_t
+stacktop_max=0;tree.SynthesizeByteCode(c83,immed,stacktop_max);if(mData->mStackSize!=stacktop_max){mData->mStackSize=unsigned(stacktop_max);
+#if !defined(FP_USE_THREAD_SAFE_EVAL) && \
+    !defined(FP_USE_THREAD_SAFE_EVAL_WITH_ALLOCA)
+mData->mStack
+x53
+stacktop_max);
+#endif
+}
+mData->mByteCode.swap(c83);mData->mImmed.swap(immed);}
+#define FUNCTIONPARSER_INSTANTIATE_EMPTY_OPTIMIZE(type) t91>lI1<type>::i22{}
+#ifdef FP_SUPPORT_MPFR_FLOAT_TYPE
+eX3(MpfrFloat)
+#endif
+#ifdef FP_SUPPORT_GMP_INT_TYPE
+eX3(GmpInt)
+#endif
+#ifdef FP_SUPPORT_COMPLEX_DOUBLE_TYPE
+eX3(std::complex<double>)
+#endif
+#ifdef FP_SUPPORT_COMPLEX_FLOAT_TYPE
+eX3(std::complex<float>)
+#endif
+#ifdef FP_SUPPORT_COMPLEX_LONG_DOUBLE_TYPE
+eX3(std::complex<long
+double>)
+#endif
+#define FUNCTIONPARSER_INSTANTIATE_OPTIMIZE(type) template lI1<type>::i22;
+#ifndef FP_DISABLE_DOUBLE_TYPE
+eY3(double)
+#endif
+#ifdef FP_SUPPORT_FLOAT_TYPE
+eY3(float)
+#endif
+#ifdef FP_SUPPORT_LONG_DOUBLE_TYPE
+eY3(long
+double)
+#endif
+#ifdef FP_SUPPORT_LONG_INT_TYPE
+eY3(long)
+#endif
+#endif // FP_SUPPORT_OPTIMIZER
+
+#endif