New upstream version 0.0.34+ds.1

1 files changed, 0 insertions, 11745 deletions

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