summaryrefslogtreecommitdiff
path: root/extrasrc
diff options
context:
space:
mode:
Diffstat (limited to 'extrasrc')
-rw-r--r--extrasrc/fp_identifier_parser.inc379
-rw-r--r--extrasrc/fp_opcode_add.inc7696
-rw-r--r--extrasrc/fpaux.hh1249
-rw-r--r--extrasrc/fptypes.hh286
4 files changed, 9610 insertions, 0 deletions
diff --git a/extrasrc/fp_identifier_parser.inc b/extrasrc/fp_identifier_parser.inc
new file mode 100644
index 0000000..7489fd0
--- /dev/null
+++ b/extrasrc/fp_identifier_parser.inc
@@ -0,0 +1,379 @@
+/* NOTE:
+ Do not include this file in your project. The fparser.cc file #includes
+this file internally and thus you don't need to do anything (other than keep
+this file in the same directory as fparser.cc).
+
+ Part of this file is generated code (by using the make_function_name_parser
+utility, found in the development version of this library). It's not intended
+to be modified by hand.
+*/
+
+ unsigned nameLength = 0;
+ const unsigned maximumNameLength = 0x80000000U-8;
+ /*
+ Due to the manner the identifier lengths are returned from
+ the readOpcode() function, the maximum supported length for
+ identifiers is 0x7FFFFFFF bytes. We minus 8 here to add some
+ buffer, because of the multibyteness of UTF-8.
+ Function names are limited to 0xFFFF bytes instead, but because
+ function names that long just are not defined, the point is moot.
+ */
+ const unsigned char* const uptr = (const unsigned char*) input;
+ typedef signed char schar;
+ while(likely(nameLength < maximumNameLength))
+ {
+ unsigned char byte = uptr[nameLength+0];
+ /* Handle the common case of A-Za-z first */
+ if(byte >= 0x40)
+ {
+ if(byte < 0x80) // 0x40..0x7F - most common case
+ {
+ // Valid characters in 40..7F: A-Za-z_
+ // Valid bitmask for 40..5F: 01111111111111111111111111100001
+ // Valid bitmask for 60..7F: 01111111111111111111111111100000
+ if(sizeof(unsigned long) == 8)
+ {
+ const unsigned n = sizeof(unsigned long)*8-32;
+ // ^ avoids compiler warning when not 64-bit
+ unsigned long masklow6bits = 1UL << (byte & 0x3F);
+ if(masklow6bits & ~((1UL << 0) | (0x0FUL << (0x1B ))
+ | (1UL << n) | (0x1FUL << (0x1B+n))))
+ { ++nameLength; continue; }
+ }
+ else
+ {
+ unsigned masklow5bits = 1 << (byte & 0x1F);
+ if((masklow5bits & ~(1 | (0x1F << 0x1B))) || byte == '_')
+ { ++nameLength; continue; }
+ }
+ break;
+ }
+ if(byte < 0xF0)
+ {
+ if(byte < 0xE0)
+ {
+ if(byte < 0xC2) break; // 0x80..0xC1
+ if(byte == 0xC2 && uptr[nameLength+1]==0xA0) break; // skip nbsp
+ // C2-DF - next common case when >= 0x40
+ // Valid sequence: C2-DF 80-BF
+ if(schar(uptr[nameLength+1]) > schar(0xBF)) break;
+ nameLength += 2;
+ continue;
+ }
+ if(byte == 0xE0) // E0
+ {
+ // Valid sequence: E0 A0-BF 80-BF
+ if((unsigned char)(uptr[nameLength+1] - 0xA0) > (0xBF-0xA0)) break;
+ }
+ else
+ {
+ if(byte == 0xED) break; // ED is invalid
+ // Valid sequence: E1-EC 80-BF 80-BF
+ // And: EE-EF 80-BF 80-BF
+ if(byte == 0xE2)
+ {
+ // break on various space characters
+ if(uptr[nameLength+1] == 0x80
+ && (schar(uptr[nameLength+2]) <= schar(0x8B)
+ || (uptr[nameLength+2] == 0xAF))) break;
+ if(uptr[nameLength+1] == 0x81
+ && uptr[nameLength+2] == 0x9F) break;
+ } else
+ if(byte == 0xE3 && uptr[nameLength+1] == 0x80
+ && uptr[nameLength+2] == 0x80) break; // this too
+
+ if(schar(uptr[nameLength+1]) > schar(0xBF)) break;
+ }
+ if(schar(uptr[nameLength+2]) > schar(0xBF)) break;
+ nameLength += 3;
+ continue;
+ }
+ if(byte == 0xF0) // F0
+ {
+ // Valid sequence: F0 90-BF 80-BF 80-BF
+ if((unsigned char)(uptr[nameLength+1] - 0x90) > (0xBF-0x90)) break;
+ }
+ else
+ {
+ if(byte > 0xF4) break; // F5-FF are invalid
+ if(byte == 0xF4) // F4
+ {
+ // Valid sequence: F4 80-8F
+ if(schar(uptr[nameLength+1]) > schar(0x8F)) break;
+ }
+ else
+ {
+ // F1-F3
+ // Valid sequence: F1-F3 80-BF 80-BF 80-BF
+ if(schar(uptr[nameLength+1]) > schar(0xBF)) break;
+ }
+ }
+ if(schar(uptr[nameLength+2]) > schar(0xBF)) break;
+ if(schar(uptr[nameLength+3]) > schar(0xBF)) break;
+ nameLength += 4;
+ continue;
+ }
+ if(nameLength > 0)
+ {
+ if(sizeof(unsigned long) == 8)
+ {
+ // Valid bitmask for 00..1F: 00000000000000000000000000000000
+ // Valid bitmask for 20..3F: 00000000000000001111111111000000
+ const unsigned n = sizeof(unsigned long)*8-32;
+ // ^ avoids compiler warning when not 64-bit
+ unsigned long masklow6bits = 1UL << byte;
+ if(masklow6bits & (((1UL << 10)-1UL) << (16+n)))
+ { ++nameLength; continue; }
+ }
+ else
+ {
+ if(byte >= '0' && byte <= '9')
+ { ++nameLength; continue; }
+ }
+ }
+ break;
+ }
+
+ /* This function generated with make_function_name_parser.cc */
+#define lO l3 lH
+#define lN switch(
+#define lM l4 lH
+#define lL if('i' l5
+#define lK 'n' l5
+#define lJ 0x80000003U;
+#define lI l1 3]={
+#define lH case
+#define lG 0x80000005U;
+#define lF )==0)l0(
+#define lE l8 3;}lH
+#define lD std::memcmp(uptr+
+#define lC l2 3 lF
+#define lB lA 1]){lH
+#define lA :lN uptr[
+#define l9 'a' lB
+#define l8 default:l0
+#define l7 lG l0 5;}lH
+#define l6 <<16)|
+#define l5 ==uptr[
+#define l4 lJ l0 3;
+#define l3 0x80000004U;l0 4;
+#define l2 lD 1,tmp,
+#define l1 static const char tmp[
+#define l0 return
+lN
+nameLength){lH
+2:lL
+0]&&'f' l5
+1])l0(cIf
+l6
+0x80000002U;l0
+2;lH
+3
+lA
+0]){lH
+l9'b':if('s' l5
+2])l0(cAbs
+l6
+lM'r':if('g' l5
+2])l0(cArg
+l6
+l4
+lE'c' lB'o' lA
+2]){lH's':l0(cCos
+l6
+lJ
+lH't':l0(cCot
+l6
+lJ
+lE's':if('c' l5
+2])l0(cCsc
+l6
+l4
+lE'e':if('x' l5
+1]&&'p' l5
+2])l0(cExp
+l6
+lM'i':if(lK
+1]&&'t' l5
+2])l0(cInt
+l6
+lM'l':if('o' l5
+1]&&'g' l5
+2])l0(cLog
+l6
+lM'm' lB'a':if('x' l5
+2])l0(cMax
+l6
+lM'i':if(lK
+2])l0(cMin
+l6
+l4
+lE'p':if('o' l5
+1]&&'w' l5
+2])l0(cPow
+l6
+lM's' lB'e':if('c' l5
+2])l0(cSec
+l6
+lM'i':if(lK
+2])l0(cSin
+l6
+l4
+lE't':if('a' l5
+1]&&lK
+2])l0(cTan
+l6
+l4
+lE
+4
+lA
+0]){lH
+l9'c':if('o' l5
+2]&&'s' l5
+3])l0(cAcos
+l6
+lO's':lL
+2]&&lK
+3])l0(cAsin
+l6
+lO't':if('a' l5
+2]&&lK
+3])l0(cAtan
+l6
+l3
+l8
+4;}
+lH'c' lB'b':if('r' l5
+2]&&'t' l5
+3])l0(cCbrt
+l6
+lO'e':lL
+2]&&'l' l5
+3])l0(cCeil
+l6
+lO'o' lA
+2]){lH'n':if('j' l5
+3])l0(cConj
+l6
+lO's':if('h' l5
+3])l0(cCosh
+l6
+l3
+l8
+4;}
+l8
+4;}
+lH'e':{lI'x','p','2'}
+;if(lC
+cExp2
+l6
+l3}
+lH'i':{lI'm','a','g'}
+;if(lC
+cImag
+l6
+l3}
+lH'l':{lI'o','g','2'}
+;if(lC
+cLog2
+l6
+l3}
+lH'r':{lI'e','a','l'}
+;if(lC
+cReal
+l6
+l3}
+lH's' lB'i':if(lK
+2]&&'h' l5
+3])l0(cSinh
+l6
+lO'q':if('r' l5
+2]&&'t' l5
+3])l0(cSqrt
+l6
+l3
+l8
+4;}
+lH't':{lI'a','n','h'}
+;if(lC
+cTanh
+l6
+l3}
+l8
+4;}
+lH
+5
+lA
+0]){lH
+l9'c':{lI'o','s','h'}
+;if(lD
+2,tmp,3
+lF
+cAcosh
+l6
+l7's':{lI'i','n','h'}
+;if(lD
+2,tmp,3
+lF
+cAsinh
+l6
+l7't':if('a' l5
+2]){if(lK
+3]){lN
+uptr[4]){lH'2':l0(cAtan2
+l6
+lG
+lH'h':l0(cAtanh
+l6
+lG
+l8
+5;}
+}
+l0
+5;}
+l0
+5;l8
+5;}
+lH'f':{l1
+4]={'l','o','o','r'}
+;if(l2
+4
+lF
+cFloor
+l6
+l7'h':{l1
+4]={'y','p','o','t'}
+;if(l2
+4
+lF
+cHypot
+l6
+l7'l':{l1
+4]={'o','g','1','0'}
+;if(l2
+4
+lF
+cLog10
+l6
+l7'p':{l1
+4]={'o','l','a','r'}
+;if(l2
+4
+lF
+cPolar
+l6
+l7't':{l1
+4]={'r','u','n','c'}
+;if(l2
+4
+lF
+cTrunc
+l6
+lG
+l0
+5;}
+l8
+5;}
+default:break;}
+l0
+nameLength;
diff --git a/extrasrc/fp_opcode_add.inc b/extrasrc/fp_opcode_add.inc
new file mode 100644
index 0000000..331ef49
--- /dev/null
+++ b/extrasrc/fp_opcode_add.inc
@@ -0,0 +1,7696 @@
+/* Function Parser for C++ v4.5.2
+
+ NOTE:
+ Do not include this file in your project. The fparser.cc file #includes
+this file internally and thus you don't need to do anything (other than keep
+this file in the same directory as fparser.cc).
+
+ This file contains generated code and is thus not intended to be to
+be modified by hand. It was generated by util/bytecoderules_parser, which
+is available in the development package.
+*/
+#define HasInvalidRangesOpcode HasInvalidRangesOpcode<IsComplexType<Value_t>::result>
+#define FP_TRACE_BYTECODE_OPTIMIZATION(srcline,from,to,with) \
+ /*std::cout << "Changing \"" from "\"\t(line " #srcline ")\n" \
+ " into \"" to "\"\n" with << std::flush*/
+#define FP_TRACE_OPCODENAME(op) \
+ (op < VarBegin \
+ ? FP_GetOpcodeName(OPCODE(op)) \
+ : findName(mData->mNamePtrs,op,NameData<Value_t>::VARIABLE))
+#define FP_TRACE_BYTECODE_ADD(opcode) \
+ /*std::cout << "Adding opcode: " << FP_TRACE_OPCODENAME(opcode) \
+ << ", bytecode length " << data->ByteCode.size() \
+ << ", pointer is " << (void*)ByteCodePtr \
+ << ", code is " << (data->ByteCode.empty() \
+ ? (void*)0 \
+ : (void*)&data->ByteCode[0]) \
+ << std::endl*/
+#define qH1 " B" mF
+#define qG1 gT y*x;
+#define qF1 hV 2;qI
+#define qE1 <<"," aD
+#define qD1 <<"," aB
+#define qC1 "cNeg"
+#define qB1 wA"," aD
+#define qA1 "x[x!=Value_t(0)] "
+#define q91 <<"," a8
+#define q81 wA"," a1
+#define q71 );qW q6
+#define q61 "cPow "
+#define q51 "cSqrt"
+#define q41 "cSqr "
+#define q31 " cExp2"
+#define q21 "cExp "
+#define q11 ){hD wB
+#define q01 "cCeil"
+#define mZ "cImag"
+#define mY "cConj"
+#define mX "cDup "
+#define mW hO wB
+#define mV "cAbs"
+#define mU wQ wH" "
+#define mT qS w2 wB
+#define mS "cFloor"
+#define mR "cTan"
+#define mQ " cDup"
+#define mP "cSin"
+#define mO (y hX;
+#define mN "[ y+x]"
+#define mM hV 2 gC
+#define mL " cExp"
+#define mK "A " wX
+#define mJ "cLess"
+#define mI "[-x]" wH
+#define mH "cDiv" a7
+#define mG "cLog"
+#define mF " cDiv"
+#define mE " " a6
+#define mD " " aF
+#define mC "cMin"
+#define mB "cMax"
+#define mA aY"x "
+#define m9 gN wB
+#define m8 "x cPow"
+#define m7 g1 oG wB
+#define m6 (x);gJ
+#define m5 "B cSqr"
+#define m4 oH dE wB
+#define m3 "[y*x]" wH
+#define m2 "cGreater"
+#define m1 mV" " wL
+#define m0 "cNeg "
+#define aZ " cAdd"
+#define aY "y "
+#define aX "B[IsVarOpcode(B)] "
+#define aW " cSub"
+#define aV gY if(dO wB
+#define aU "cInv"
+#define aT mX aU
+#define aS "cAbsNot"
+#define aR "cLessOrEq"
+#define aQ "cAdd " q51
+#define aP "[y*x] cPow"
+#define aO "cCos"
+#define aN "cLog2"
+#define aM "cCosh"
+#define aL "cLog10"
+#define aK "B[B==A]"
+#define aJ "cNotNot"
+#define aI " " a2
+#define aH "cDup" aZ
+#define aG "cGreaterOrEq"
+#define aF "x" aZ
+#define aE "cEqual"
+#define aD " " aC
+#define aC "A" wY
+#define aB " " wU
+#define aA " cNeg"
+#define a9 " cRDiv"
+#define a8 " B" wY
+#define a7 " x" wH
+#define a6 "cRSub"
+#define a5 "A[IsVarOpcode(A)]"
+#define a4 "x[x!=Value_t()] "
+#define a3 " " a5" "
+#define a2 " with" aD
+#define a1 " " wG
+#define a0 " cNot"
+#define wZ "x[x==Value_t()]" wH
+#define wY " " wC
+#define wX "[x]" wH
+#define wW "cNEqual"
+#define wV a5 mF
+#define wU "x = "<<x
+#define wT "x[isInteger(x)] cPow"
+#define wS a5 wH
+#define wR "x[x!=Value_t(0)]" mF
+#define wQ "x[x>Value_t(0)]"
+#define wP "B[IsNeverNegativeValueOpcode(B)] "
+#define wO "x[x==Value_t(1)] "
+#define wN wA"\n"
+#define wM <<"\n"
+#define wL "x[x==Value_t(0)] "
+#define wK "B[IsBinaryOpcode(B)&&!HasInvalidRangesOpcode(B)] " wD
+#define wJ "A[IsNeverNegativeValueOpcode(A)] "
+#define wI "A[IsVarOpcode(A)&&mData->mByteCode.size()>2] "
+#define wH " cMul"
+#define wG aY"= "<<y wM
+#define wF " x A[IsComparisonOpcode(A)]"
+#define wE FP_TRACE_BYTECODE_ADD
+#define wD "A[IsBinaryOpcode(A)&&!HasInvalidRangesOpcode(A)] " wZ
+#define wC "= "<<FP_TRACE_OPCODENAME
+#define wB FP_TRACE_BYTECODE_OPTIMIZATION
+#define wA " with" aB<<
+#define w9 qT q6:
+#define w8 cEqual
+#define w7 Lbd gY
+#define w6 Lcb gY
+#define w5 opcode
+#define w4 B==A){
+#define w3 q5 q4
+#define w2 cExp:
+#define w1 qO A qP
+#define w0 qO h2
+#define oZ qF g1
+#define oY if dC
+#define oX fp_pow(
+#define oW fp_log(
+#define oV 3 gC A
+#define oU x==g1 oG
+#define oT gX Lml;
+#define oS q4 Lbo
+#define oR 3 gH
+#define oQ cSinh:
+#define oP g1 0)
+#define oO 0.5)){
+#define oN Ldn;qT
+#define oM ]==h3){
+#define oL qY g8 0
+#define oK .size()
+#define oJ );qE
+#define oI A oJ dU
+#define oH g7 A=
+#define oG 1)){
+#define oF qU hI
+#define oE Lbo oF
+#define oD qT hM hB
+#define oC qL 3]
+#define oB :hC qQ oC
+#define oA cSub oB d3 hJ
+#define o9 q7=-x
+#define o8 gX Loi;
+#define o7 );qF
+#define o6 qE A o7
+#define o5 h3 d4 qL
+#define o4 fp_log2(
+#define o3 ==cSqr){
+#define o2 qT cSqr:
+#define o1 cGreater
+#define o0 Default6
+#define dZ Default5
+#define dY Default2
+#define dX Default1
+#define dW ImmedPtr
+#define dV gA qZ qC
+#define dU h3);
+#define dT gC dU
+#define dS cNotNot
+#define dR fp_log10(
+#define dQ cAbs);
+#define dP fp_abs(x)
+#define dO x>oP){
+#define dN mImmed
+#define dM qE h3 gX
+#define dL qK dJ w3
+#define dK cGreaterOrEq
+#define dJ =q6;
+#define dI qK dJ g6
+#define dH Value_t
+#define dG q8 2 gH q4
+#define dF q0[0]
+#define dE qK qR qX
+#define dD qK qR IsLogicalOpcode(h2
+#define dC (qK==
+#define dB hB oY
+#define dA qY g8 oG
+#define d9 pop_back()
+#define d8 q6;q1 h3 gI
+#define d7 q8 2 gC
+#define d6 hR Lba;
+#define d5 Default4 qU
+#define d4 :if(
+#define d3 qV hS d4 qL
+#define d2 h3 gM if
+#define d1 IsVarOpcode(
+#define d0 mData->
+#define hZ ]qR w4
+#define hY gX Llq
+#define hX ,x gX Lap
+#define hW gT y+x;q8
+#define hV for qA
+#define hU gQ cAbs:
+#define hT unsigned
+#define hS cAdd
+#define hR ,y gX
+#define hQ qL 3 hZ
+#define hP y=q3-1]qR
+#define hO y gO
+#define hN qY if(dP
+#define hM q6:qC
+#define hL :if gF
+#define hK qQ h9 hS hL
+#define hJ 4 qZ mW(292,aY"cAdd B[IsVarOpcode(B)]" aW mD,mN aZ" B" aW,wA"," a8(B)<<"," a1);q4
+#define hI cNeg:
+#define hH :qS cDup:
+#define hG hS hH hK h1 wB(310,aH" " aH,"[Value_t(4)]" wH,);q4
+#define hF (x!=g1
+#define hE qL 2]
+#define hD B g4 w4
+#define hC B=hE qO B)){
+#define hB if hF 0)){
+#define hA gX Lng;
+#define h9 qK qV
+#define h8 }break;
+#define h7 <dH>()){
+#define h6 hR Lap;
+#define h5 isEvenInteger(
+#define h4 DegreesToRadians(x
+#define h3 cMul
+#define h2 A)){
+#define h1 ]==cDup){
+#define h0 hI wB(201,m0 mV,mV,);q4 Lab qU qB
+#define gZ 3 h1 wB(311,aH wH" " aH,"cMul [Value_t(4)]" wH,);q4
+#define gY qU hM
+#define gX );q4
+#define gW y,x gX Lba;
+#define gV IsUnaryOpcode(
+#define gU g6 w5=
+#define gT q3-1]=
+#define gS gR qR IsAlwaysIntegerOpcode(h2
+#define gR ;oH dF
+#define gQ )){qQ h9
+#define gP break gR qO A gQ
+#define gO =q3-1];
+#define gN qJ hO
+#define gM :qJ qC
+#define gL d2(dO
+#define gK ]=q6 q9 2 gH
+#define gJ return;
+#define gI );w5=
+#define gH ;qI q5
+#define gG qL 2 gK q0-=2;
+#define gF (qL 2
+#define gE y;hT B;hT
+#define gD d0 mByteCode
+#define gC ;qI q1
+#define gB q9 2 gC h3 gI
+#define gA ){if gF
+#define g9 oY h3 dV
+#define g8 if(x==g1
+#define g7 default:
+#define g6 q5 q0-=1;
+#define g5 if(!q0){q2
+#define g4 =hE qR
+#define g3 B g4 IsNeverNegativeValueOpcode(B)){
+#define g2 &&!HasInvalidRangesOpcode(
+#define g1 dH(
+#define g0 FP_ReDefinePointers();
+#define qZ ]==q6){
+#define qY if(q0[0 qZ qC
+#define qX IsNeverNegativeValueOpcode(h2
+#define qW gD qD
+#define qV ){case
+#define qU ;case
+#define qT }break qU
+#define qS qQ dF qV
+#define qR ;if(
+#define qQ switch(
+#define qP )&&gD oK>
+#define qO qR d1
+#define qN dF w1 2){
+#define qM d0 dN.d9;
+#define qL q0[-
+#define qK qL 1]
+#define qJ oY q6){
+#define qI tmp-->0;)
+#define qH q4 Default0;
+#define qG }}qH
+#define qF d0 dN qD
+#define qE AddFunctionOpcode(
+#define qD .push_back(
+#define qC x=q7;
+#define qB hM wB(132,"x " mV,"[fp_abs(x)]",wN);q4 Lac;
+#define qA (hT tmp=
+#define q9 ;hV
+#define q8 d0 dN.d9 q9
+#define q7 q3 0]
+#define q6 cImmed
+#define q5 gD.d9;
+#define q4 goto
+#define q3 dW[
+#define q2 q4 Laa;}case
+#define q1 q5 qE
+#define q0 ByteCodePtr
+hT*q0;dH*dW;
+#define FP_ReDefinePointers() q0=!gD.empty()?&gD[0]+gD oK-1:0;dW=!d0 dN.empty()?&d0 dN[0]+d0 dN oK-1:0;
+g0
+wE(opcode);
+#if(!(FP_COMPLEX_VERSION) && !(FP_FLOAT_VERSION))
+dH
+x;hT
+A;dH
+gE
+C;hT
+D;qQ
+w5){TailCall_cAbs:g5
+cAbs:qS
+h0
+oH
+dF
+qR
+qX
+wB(393,wJ
+mV,"A"
+,aI(A)wM);gJ
+qG
+TailCall_cAdd:g5
+hG
+Lad;qT
+h3
+hL]==hS){if(qL
+gZ
+Lae;}
+h8}
+q4
+dX
+qU
+d2
+gF
+h1
+wB(313,"cDup"
+a7
+aZ,"[x+Value_t(1)]"
+wH,wN);q4
+Laf;}
+}
+q4
+dX
+oF
+wB(199,qC1
+aZ,"cSub"
+,);q4
+Lag
+gY
+hK
+qZ
+mW(127,aY"cAdd"
+mD,"[y+x]"
+aZ,q81);q4
+Lah;qT
+cRSub:qQ
+hE
+d3
+3
+qZ
+mW(298,aY"cAdd"
+mE
+mD,mN
+aZ
+mE,q81);q4
+Lai;qT
+hI
+wB(299,m0
+a6
+mD,"[-x]"
+aZ
+mE,wN);q4
+Laj
+qU
+q6:mW(297,aY
+a6
+mD,mN
+mE,q81);q4
+Lak;qT
+oA
+Lal;qT
+hI
+wB(293,m0"B[IsVarOpcode(B)]"
+aW
+mD,"[-x]"
+aZ" B"
+aW,wA","
+a8(B)wM);q4
+Lam
+qU
+q6:mW(291,aY"B[IsVarOpcode(B)]"
+aW
+mD,mN" B"
+aW,wA","
+a8(B)<<","
+a1);q4
+Lan;}
+w9
+mW(105,aY
+aF,"[y+x]"
+,q81);q4
+Lao;}
+g8)){wB(57,"x[x==Value_t()]"
+aZ,,wN);q4
+Lap;h8
+g7
+dX:;A=dF
+w0
+oY
+cRSub
+dV
+wB(290,"x"
+mE
+a3"cAdd"
+,"[DO_STACKPLUS1] A [x]"
+aZ
+mE,aI(A)qD1
+wM);incStackPtr();--mStackPtr;q4
+Laq;}
+wB(295,a6
+a3"cAdd"
+,"[DO_STACKPLUS1] A"
+aZ
+mE,aI(A)wM);incStackPtr();--mStackPtr;q4
+Lba;}
+qG
+TailCall_cAnd:g5
+cAnd
+hH
+wB(224,mX"cAnd"
+,aJ,);q4
+Lbb
+gY
+m9(117,mA"cAnd"
+,"[fp_and(x,y)]"
+,q81);q4
+Lbc;h8}
+qH
+TailCall_cDiv:g5
+cDiv
+hH
+wB(78,"cDup"
+mF,"[Value_t()]"
+wH" [Value_t(1)]"
+aZ,);q4
+w7
+if
+hF
+gQ
+hI
+wB(125,m0
+a4"cDiv"
+,"[-x]"
+mF,wN);q4
+Lbe
+qU
+q6:mW(103,aY
+a4"cDiv"
+,"[y/x]"
+,q81);q4
+Lbf;}
+}
+g8
+oG
+wB(56,wO"cDiv"
+,,wN);q4
+Lap;h8}
+qH
+TailCall_cEqual:g5
+w8:dA
+A=dD
+wB(421,"A[IsLogicalOpcode(A)] "
+wO
+aE,"A"
+,qB1(A)wM);q4
+Lap;}
+}
+m9(115,mA
+aE,"[fp_equal(y,x)]"
+,q81);q4
+Lbg;}
+g8
+0
+hU
+wB(359,m1
+aE,"[x] "
+aE,wN);q4
+Lbh
+qU
+cSqr:wB(361,q41
+wL
+aE,"[x] "
+aE,wN);q4
+Lbh;}
+wB(411,wL
+aE,"cNot"
+,wN);q4
+Lbi;qG
+TailCall_cGreater:g5
+o1:oL
+hU
+wB(413,m1
+m2,aJ,wN);q4
+Lbj;m4(417,wJ
+wL
+m2,"A "
+aJ,qB1(A)wM);q4
+Lbk;}
+}
+}
+m9(113,mA
+m2,"[fp_less(x,y)]"
+,q81);q4
+Lbl;qG
+TailCall_cGreaterOrEq:g5
+dK:qY
+g8
+1
+hU
+wB(414,mV" "
+wO
+aG,aJ,wN);q4
+Lbj;m4(418,wJ
+wO
+aG,"A "
+aJ,qB1(A)wM);q4
+Lbk;}
+}
+}
+m9(114,mA
+aG,"[fp_lessOrEq(x,y)]"
+,q81);q4
+Lbm;qG
+TailCall_cInv:g5
+cInv:qY
+if
+hF)){wB(101,a4
+aU,"[Value_t(1)/x]"
+,wN);q4
+Lbn;qG
+TailCall_cLess:g5
+cLess:oL)){A=dE
+wB(301,wJ
+wL
+mJ,mK,qB1(A)wM);oS;}
+}
+g8
+1
+hU
+wB(415,mV" "
+wO
+mJ,"cNot"
+,wN);q4
+Lbp;m4(419,wJ
+wO
+mJ,"A"
+a0,qB1(A)wM);q4
+Lbi;}
+}
+}
+m9(111,mA
+mJ,"[fp_less(y,x)]"
+,q81);q4
+Lbq;qG
+TailCall_cLessOrEq:g5
+cLessOrEq:oL
+hU
+wB(416,m1
+aR,"cNot"
+,wN);q4
+Lbp;m4(420,wJ
+wL
+aR,"A"
+a0,qB1(A)wM);q4
+Lbi;}
+}
+}
+m9(112,mA
+aR,"[fp_lessOrEq(y,x)]"
+,q81);q4
+Lca;qG
+TailCall_cMax:g5
+cMax
+hH
+wB(60,mX
+mB,,);q4
+w6
+m9(141,mA
+mB,"[fp_max(x,y)]"
+,q81);q4
+Lcc;}
+gP
+cDup:hD
+wB(66,aK
+mQ
+a3
+mB,"B"
+mQ,aI(A)q91(B)wM);q4
+Lcb;qT
+cMax:hD
+wB(68,aK" "
+mB
+a3
+mB,"B "
+mB,aI(A)q91(B)wM);q4
+Lcb;h8}
+qG
+TailCall_cMin:g5
+cMin
+hH
+wB(59,mX
+mC,,);q4
+w6
+m9(140,mA
+mC,"[fp_min(x,y)]"
+,q81);q4
+Lcd;}
+gP
+cDup:hD
+wB(65,aK
+mQ
+a3
+mC,"B"
+mQ,aI(A)q91(B)wM);q4
+Lcb;qT
+cMin:hD
+wB(67,aK" "
+mC
+a3
+mC,"B "
+mC,aI(A)q91(B)wM);q4
+Lcb;h8}
+qG
+TailCall_cMod:g5
+cMod:qY
+if
+hF)){m9(104,aY
+a4"cMod"
+,"[fp_mod(y,x)]"
+,q81);q4
+Lce;}
+qG
+TailCall_cMul:g5
+h3
+hH
+wB(202,"cDup"
+wH,"cSqr"
+,);q4
+Lcf
+oF
+qQ
+h9
+cDup:wB(467,"cDup"
+aA
+wH,"cSqr"
+aA,);q4
+Lcg;oH
+qK
+qO
+A)gA
+oM
+B=hQ
+wB(473,aK
+wH
+a3
+qC1
+wH,m5
+wH
+aA,aI(A)q91(B)wM);q4
+Lch;}
+}
+}
+}
+q4
+dY
+qU
+cPow
+gM
+if
+gF
+h1
+wB(314,mX
+m8
+wH,"[x+Value_t(1)] cPow"
+,wN);q4
+Lci;}
+}
+q4
+dY
+gY
+g8
+gQ
+h3:A=hE
+w0
+wB(93,wS" "
+wZ,wX,qB1(A)wM);q4
+Lcj;}
+q4
+Default3;g7
+Default3:;A=qK
+qR
+IsBinaryOpcode(A)g2
+h2
+qQ
+hE
+qV
+q6:mW(92,aY
+wD,wX,qB1(A)<<","
+a1);q4
+Lck;g7
+B
+g4
+IsBinaryOpcode(B)g2
+B)){qQ
+oC
+qV
+q6:mW(96,aY
+wK,mK,qB1(A)q91(B)<<","
+a1);q4
+Lcl;g7
+C=oC
+qO
+C)){wB(94,"C[IsVarOpcode(C)] "
+wK,mK,qB1(A)q91(B)<<", C"
+wY(C)wM);q4
+Lcm;}
+if(gV
+C)g2
+C)){wB(95,"C[IsUnaryOpcode(C)&&!HasInvalidRangesOpcode(C)] "
+wK,"B "
+mK,qB1(A)q91(B)<<", C"
+wY(C)wM);q4
+Lcn;}
+}
+}
+if(d1
+B)){wB(90,aX
+wD,wX,qB1(A)q91(B)wM);q4
+Lcj;}
+if(gV
+B)g2
+B)){wB(91,"B[IsUnaryOpcode(B)&&!HasInvalidRangesOpcode(B)] "
+wD,mK,qB1(A)q91(B)wM);q4
+Lco;}
+}
+}
+if(d1
+h2
+wB(88,a5" "
+wZ,"[x]"
+,qB1(A)wM);q4
+Lcp;}
+if(gV
+A)g2
+h2
+wB(89,"A[IsUnaryOpcode(A)&&!HasInvalidRangesOpcode(A)] "
+wZ,wX,qB1(A)wM);q4
+Lcq;}
+}
+}
+qQ
+h9
+hS:qQ
+hE
+qV
+cDup:wB(317,aH
+a7,"[x+x]"
+wH,wN);q4
+Lda
+qU
+o5
+3
+qZ
+hO
+A=qL
+4]w0
+wB(386,a5" y"
+wH
+aZ
+a7,wX" A "
+m3
+aZ,wA", "
+aY"= "
+<<y
+qE1(A)wM);q4
+Ldb;}
+w9
+mW(385,aY"cAdd"
+a7,wX" [y*x]"
+aZ,q81);q4
+Ldc;qT
+h3:qQ
+hE
+d3
+3
+h1
+wB(319,aH
+wH
+a7,"cMul [x+x]"
+wH,wN);q4
+Ldd;w9
+hP
+y*oU
+wB(70,"y[y*x==Value_t(1)]"
+wH
+a7,,q81);q4
+Lde;}
+wB(128,"y"
+wH
+a7,m3,q81);q4
+Ldf;qT
+hI
+wB(122,qC1
+a7,mI,wN);q4
+Ldg
+qU
+cSub
+hL
+oM
+if(qL
+3
+qZ
+hO
+A=qL
+4]w0
+wB(387,a5" y"
+wH
+aW
+a7,wX" A "
+m3
+aW,wA", "
+aY"= "
+<<y
+qE1(A)wM);q4
+Ldh;}
+}
+w9
+mW(102,"y"
+a7,"[y*x]"
+,q81);q4
+Ldi;}
+g8
+oG
+wB(55,"x[x==Value_t(1)]"
+wH,,wN);q4
+Lap;}
+g8-oG
+wB(124,"x[x==Value_t(-1)]"
+wH,qC1,wN);q4
+Ldj;}
+g8
+2)){wB(198,"x[x==Value_t(2)]"
+wH,aH,wN);q4
+Ldk;h8
+g7
+dY:;A=dF
+qO
+A
+gQ
+h3:qQ
+hE
+qV
+hI
+B=hQ
+wB(470,aK
+aA
+wH" "
+wS,m5
+wH
+aA,aI(A)q91(B)wM);q4
+Lch;}
+q4
+Default4;g7
+Default4:;hD
+wB(461,aK
+wH" "
+wS,m5
+wH,aI(A)q91(B)wM);q4
+Ldl;}
+}
+q4
+dZ
+oF
+hD
+wB(464,aK
+aA" "
+wS,m5
+aA,aI(A)q91(B)wM);q4
+Lcg;}
+q4
+dZ;g7
+dZ:;B=qK
+qR
+w4
+wB(458,aK" "
+wS,m5,aI(A)q91(B)wM);q4
+Lcf;}
+}
+}
+if(gV
+h2
+B=qK
+qO
+B
+qP
+1
+gA
+oM
+C=oC
+qR
+C==A){D=qL
+4]qR
+D==B){wB(477,"D[D==B] C[C==A]"
+wH" B[IsVarOpcode(B)&&mData->mByteCode.size()>1] A[IsUnaryOpcode(A)]"
+wH,"D C cSqr"
+wH,aI(A)q91(B)<<", C"
+wY(C)<<", D"
+wY(D)wM);q4
+Ldm;}
+}
+}
+}
+qG
+TailCall_cNEqual:g5
+cNEqual:dA
+A=dD
+wB(422,"A[IsLogicalOpcode(A)] "
+wO
+wW,"A"
+a0,qB1(A)wM);q4
+Lbi;}
+}
+m9(116,mA
+wW,"[fp_nequal(y,x)]"
+,q81);q4
+Ldn;}
+g8
+0
+hU
+wB(360,m1
+wW,"[x] "
+wW,wN);q4
+Ldo
+qU
+cSqr:wB(362,q41
+wL
+wW,"[x] "
+wW,wN);q4
+Ldo;}
+wB(412,wL
+wW,aJ,wN);q4
+Lbk;qG
+TailCall_cNeg:g5
+hI
+qS
+h3
+gM
+wB(123,"x"
+wH
+aA,mI,wN);q4
+Ldp;qT
+hI
+wB(61,qC1
+aA,,);q4
+w6
+wB(100,"x"
+aA,"[-x]"
+,wN);q4
+Ldq;}
+qH
+TailCall_cNot:g5
+cNot:qS
+cAbs:wB(227,mV
+a0,"cNot"
+,);q4
+Lea
+qU
+cAbsNot:A=dD
+wB(389,"A[IsLogicalOpcode(A)] "
+aS
+a0,"A"
+,aI(A)wM);q4
+Lcb;}
+if(A!=q6){wB(390,"A[A!=cImmed] "
+aS
+a0,"A cAbsNotNot"
+,aI(A)wM);q4
+Leb;}
+q4
+o0
+qU
+cAbsNotNot:wB(231,"cAbsNotNot"
+a0,aS,);q4
+Lec
+qU
+hS
+gM
+wB(424,aF
+a0,"[-x] "
+aE,wN);q4
+Led;}
+q4
+o0
+qU
+w8:wB(220,aE
+a0,wW,);q4
+Lee
+qU
+o1:wB(218,m2
+a0,aR,);q4
+Lef
+qU
+dK:wB(219,aG
+a0,mJ,);q4
+Leg
+qU
+cLess:wB(216,mJ
+a0,aG,);q4
+Leh
+qU
+cLessOrEq:wB(217,aR
+a0,m2,);q4
+Lei
+qU
+cNEqual:wB(221,wW
+a0,aE,);q4
+Lej
+oF
+wB(226,qC1
+a0,"cNot"
+,);q4
+Lea
+qU
+cNot:wB(229,"cNot"
+a0,aJ,);q4
+Lbb
+qU
+dS:wB(230,aJ
+a0,"cNot"
+,);q4
+Lea
+gY
+wB(107,"x"
+a0,"[fp_not(x)]"
+,wN);q4
+Lek;g7
+o0:;A=dF
+qR
+qX
+wB(391,wJ"cNot"
+,"A "
+aS,aI(A)wM);q4
+Lel;qG
+TailCall_cNotNot:g5
+dS:qS
+hS
+gM
+wB(423,aF" "
+aJ,"[-x] "
+wW,wN);q4
+Lem;qT
+cNot:wB(232,"cNot "
+aJ,"cNot"
+,);gJ}
+qH
+TailCall_cOr:g5
+cOr
+hH
+wB(223,mX"cOr"
+,aJ,);q4
+Lbb
+gY
+m9(118,mA"cOr"
+,"[fp_or(x,y)]"
+,q81);q4
+Len;h8}
+qH
+TailCall_cRDiv:g5
+cRDiv:dA
+wB(268,wO"cRDiv"
+,aU,wN);q4
+Leo;qG
+TailCall_cRSub:g5
+cRSub
+d4
+q0[0
+h1
+wB(77,"cDup"
+mE,"[Value_t()]"
+wH,);q4
+Lep;}
+qH
+TailCall_cSqr:g5
+cSqr:qS
+cAbs:wB(204,mV" cSqr"
+,"cSqr"
+,);q4
+Leq
+oF
+wB(203,m0"cSqr"
+,"cSqr"
+,);q4
+Leq;}
+qH
+TailCall_cSub:g5
+cSub
+hH
+wB(76,"cDup"
+aW,"[Value_t()]"
+wH,);q4
+Lep
+oF
+wB(200,qC1
+aW,"cAdd"
+,);q4
+Lfa
+gY
+g8)){wB(58,"x[x==Value_t()]"
+aW,,wN);q4
+Lap;}
+m9(106,aY"x"
+aW,"[y-x]"
+,q81);q4
+Lfb;}
+wB(51,"x"
+aW,"[-x]"
+aZ,wN);q4
+Lfc
+gR
+w0
+oY
+cRSub
+dV
+wB(289,"x"
+mE
+a3"cSub"
+,"A"
+aZ" [x]"
+mE,aI(A)qD1
+wM);q4
+Lfd;}
+wB(296,a6
+a3"cSub"
+,"[DO_STACKPLUS1] A"
+aW
+mE,aI(A)wM);incStackPtr();--mStackPtr;q4
+Lfe;}
+qG
+g7
+Default0:;A=w5
+qR
+IsComparisonOpcode(h2
+qY
+hK
+qZ
+mW(364,aY"cAdd"
+wF,"[x-y] A"
+,aI(A)qD1<<","
+a1);q4
+Lff;qT
+hI
+wB(365,qC1
+wF,"[-x] {OppositeComparisonOpcode(A)}"
+,aI(A)qD1
+wM);q4
+Lfg;}
+}
+}
+if(d1
+A
+qP
+0){B=q0[0
+hZ
+wB(475,aK" A[IsVarOpcode(A)&&mData->mByteCode.size()>0]"
+,"B"
+mQ,aI(A)q91(B)wM);q4
+Lfh;}
+}
+if(gV
+h2
+B=dF
+qO
+B
+qP
+1){C=qK
+qR
+C==A){D
+g4
+D==B){wB(476,"D[D==B] C[C==A] B[IsVarOpcode(B)&&mData->mByteCode.size()>1] A[IsUnaryOpcode(A)]"
+,"D C"
+mQ,aI(A)q91(B)<<", C"
+wY(C)<<", D"
+wY(D)wM);q4
+Lfi;}
+}
+}
+}
+}
+q4
+Laa;Laa:qW
+w5);gJ
+Lab:g6
+wE(cAbs);q4
+TailCall_cAbs;Lac:q7=dP;gJ
+Lad:oZ
+4));gG
+Lfj:w5=h3;Lfk:g0
+Lfl:wE(cMul);q4
+TailCall_cMul;Lae:hV
+4
+dT
+oZ
+4)q71
+gX
+Lfj;Laf:q7=x+g1
+1);gG
+Lbo:w5=h3;q4
+Lfl;Lag:gU
+cSub;Lfm:wE(cSub);q4
+TailCall_cSub;Lah:hW
+2
+gH
+Lfn:g0
+Lfo:wE(cAdd);q4
+TailCall_cAdd;Lai:hW
+oR
+Lfp:qE
+hS);Lfq:w5=cRSub;g0
+wE(cRSub);q4
+TailCall_cRSub;Laj:o9;qL
+2
+gK
+q4
+Lfp;Lak:hW
+2
+gH
+q4
+Lfq;Lal:hW
+4
+gH
+Lga:qE
+hS);Lgb:qE
+B);Lgc:w5=cSub;g0
+q4
+Lfm;Lam:o9;oC=q6
+q9
+oR
+q4
+Lga;Lan:hW
+oR
+q4
+Lgb;Lao:gT
+y+x;Lap:qM
+Lcb:q5
+gJ
+Laq:q8
+oV
+o7
+x
+q71
+gX
+Lfp;Lba:mM
+A
+gX
+Lfp;Lbb:gU
+dS;Lgd:wE(cNotNot);q4
+TailCall_cNotNot;Lbc:gT
+fp_and(x
+h6
+Lbd:oZ));dF
+dJ
+qE
+dU
+oZ
+1));Lge:qW
+q6);Lgf:w5=hS;q4
+Lfn;Lbe:o9;dI
+wE(cDiv);q4
+TailCall_cDiv;Lbf:gT
+y/x;q4
+Lap;Lbg:gT
+fp_equal
+mO
+Lbh:dI
+Lgg:wE(cEqual);q4
+TailCall_cEqual;Lbi:qM
+q5
+Lgh:w5=cNot;g0
+Lgi:wE(cNot);q4
+TailCall_cNot;Lbj:q8
+2
+gH
+Lgj:w5=dS;g0
+q4
+Lgd;Lbk:qM
+w3
+Lgj;Lbl:gT
+fp_less(x
+h6
+Lbm:gT
+fp_lessOrEq(x
+h6
+Lbn:q7=g1
+1)/x;gJ
+Lbp:dG
+Lgh;Lbq:gT
+fp_less
+mO
+Lca:gT
+fp_lessOrEq
+mO
+Lcc:gT
+fp_max(x
+h6
+Lcd:gT
+fp_min(x
+h6
+Lce:gT
+fp_mod
+mO
+Lcf:gU
+cSqr;Lgk:wE(cSqr);q4
+TailCall_cSqr;Lcg:mM
+cSqr);Lgl:w5=cNeg;g0
+wE(cNeg);q4
+TailCall_cNeg;Lch:hV
+3
+gC
+cSqr);dM
+Lgl;Lci:q7=x+g1
+1);hE=q6
+q9
+2
+gC
+cPow);gJ
+Lcj:gG
+q4
+Lfl;Lck:gT
+x;Lgm:dG
+Lfk;Lcl:qF1
+qM
+Lgn:hV
+4
+gH
+Lgo:o6
+x);Lgp:qW
+q6
+gX
+Lfk;Lcm:qM
+q4
+Lgn;Lcn:q8
+4
+gC
+B
+gX
+Lgo;Lco:q8
+oR
+q4
+Lgo;Lcp:qK
+dJ
+q4
+Lcb;Lcq:dI
+q4
+Lfl;Lda:q7=x+x;q4
+Lcj;Ldb:gT
+x;qL
+4]dJ
+q8
+4
+dT
+o6
+y*x
+q71);dM
+Lgf;Ldc:gT
+x;d7
+dU
+qF
+y*x
+gX
+Lge;Ldd:q8
+4
+dT
+qF
+x+x
+gX
+Lgp;Lde:qF1
+q8
+oR
+gJ
+Ldf:qG1
+q4
+Lgm;Ldg:o9;q4
+Lcq;Ldh:gT
+x;qL
+4]dJ
+q8
+4
+dT
+o6
+y*x
+q71);dM
+Lgc;Ldi:qG1
+q4
+Lap;Ldj:qM
+w3
+Lgl;Ldk:dF=cDup;dW-=1;qM
+Lgq:w5=hS;q4
+Lfo;Ldl:hV
+2
+gH
+Lha:qE
+cSqr
+gX
+Lfk;Ldm:hV
+oR
+q4
+Lha;Ldn:gT
+fp_nequal
+mO
+Ldo:dI
+Lhb:wE(cNEqual);q4
+TailCall_cNEqual;Ldp:o9;g6
+oS;Ldq:o9;gJ
+Lea:g6
+q4
+Lgi;Leb:q1
+cAbsNotNot);gJ
+Lec:q5
+Lel:qE
+cAbsNot);gJ
+Led:o9;Lej:gU
+w8;q4
+Lgg;Lee:gU
+cNEqual;q4
+Lhb;Lef:gU
+cLessOrEq;wE(cLessOrEq);q4
+TailCall_cLessOrEq;Leg:gU
+cLess;wE(cLess);q4
+TailCall_cLess;Leh:gU
+dK;wE(cGreaterOrEq);q4
+TailCall_cGreaterOrEq;Lei:gU
+o1;wE(cGreater);q4
+TailCall_cGreater;Lek:q7=fp_not
+m6
+Lem:o9;q4
+Lee;Len:gT
+fp_or(x
+h6
+Leo:qM
+q5
+w5=cInv;g0
+wE(cInv);q4
+TailCall_cInv;Lep:oZ));dF
+dJ
+q4
+Lfj;Leq:g6
+q4
+Lgk;Lfa:g6
+q4
+Lgq;Lfb:gT
+y-x;q4
+Lap;Lfc:o9;q4
+Lgq;Lfd:q8
+oV
+oJ
+hS
+o7
+x
+q71
+gX
+Lfq;Lfe:mM
+A
+oJ
+cSub
+gX
+Lfq;Lff:gT
+x-y;d7
+A);gJ
+Lfg:o9;qK
+dJ
+q1
+OppositeComparisonOpcode(A));gJ
+Lfh:qW
+cDup);gJ
+Lfi:dF=cDup;gJ
+gJ
+q4
+TailCall_cAnd;q4
+TailCall_cMax;q4
+TailCall_cMin;q4
+TailCall_cMod;q4
+TailCall_cNeg;q4
+TailCall_cOr;q4
+TailCall_cRDiv;q4
+TailCall_cSub;
+#endif
+#if((FP_COMPLEX_VERSION) && !(FP_FLOAT_VERSION))
+dH
+x;dH
+gE
+A;hT
+C;hT
+D;qQ
+w5){TailCall_cAbs:g5
+cAbs:qS
+h0}
+qH
+TailCall_cAdd:g5
+hG
+Lad;qT
+h3
+hL]==hS){if(qL
+gZ
+Lae;}
+h8}
+q4
+dX
+qU
+d2
+gF
+h1
+wB(313,"cDup"
+a7
+aZ,"[x+Value_t(1)]"
+wH,wN);q4
+Laf;}
+}
+q4
+dX
+oF
+wB(199,qC1
+aZ,"cSub"
+,);q4
+Lag
+gY
+hK
+qZ
+mW(127,aY"cAdd"
+mD,"[y+x]"
+aZ,q81);q4
+Lah;qT
+cRSub:qQ
+hE
+d3
+3
+qZ
+mW(298,aY"cAdd"
+mE
+mD,mN
+aZ
+mE,q81);q4
+Lai;qT
+hI
+wB(299,m0
+a6
+mD,"[-x]"
+aZ
+mE,wN);q4
+Laj
+qU
+q6:mW(297,aY
+a6
+mD,mN
+mE,q81);q4
+Lak;qT
+oA
+Lal;qT
+hI
+wB(293,m0"B[IsVarOpcode(B)]"
+aW
+mD,"[-x]"
+aZ" B"
+aW,wA","
+a8(B)wM);q4
+Lam
+qU
+q6:mW(291,aY"B[IsVarOpcode(B)]"
+aW
+mD,mN" B"
+aW,wA","
+a8(B)<<","
+a1);q4
+Lan;}
+w9
+mW(105,aY
+aF,"[y+x]"
+,q81);q4
+Lao;}
+g8)){wB(57,"x[x==Value_t()]"
+aZ,,wN);q4
+Lap;h8
+g7
+dX:;A=dF
+w0
+oY
+cRSub
+dV
+wB(290,"x"
+mE
+a3"cAdd"
+,"[DO_STACKPLUS1] A [x]"
+aZ
+mE,aI(A)qD1
+wM);incStackPtr();--mStackPtr;q4
+Laq;}
+wB(295,a6
+a3"cAdd"
+,"[DO_STACKPLUS1] A"
+aZ
+mE,aI(A)wM);incStackPtr();--mStackPtr;q4
+Lba;}
+qG
+TailCall_cAnd:g5
+cAnd
+hH
+wB(224,mX"cAnd"
+,aJ,);q4
+Lbb
+gY
+m9(117,mA"cAnd"
+,"[fp_and(x,y)]"
+,q81);q4
+Lbc;h8}
+qH
+TailCall_cConj:g5
+cConj:qS
+cConj:wB(63,mY" "
+mY,,);q4
+w7
+wB(193,"x "
+mY,"[fp_conj(x)]"
+,wN);q4
+Lbe;}
+qH
+TailCall_cDiv:g5
+cDiv
+hH
+wB(78,"cDup"
+mF,"[Value_t()]"
+wH" [Value_t(1)]"
+aZ,);q4
+Lbf
+gY
+if
+hF
+gQ
+hI
+wB(125,m0
+a4"cDiv"
+,"[-x]"
+mF,wN);q4
+Lbg
+qU
+q6:mW(103,aY
+a4"cDiv"
+,"[y/x]"
+,q81);q4
+Lbh;}
+}
+g8
+oG
+wB(56,wO"cDiv"
+,,wN);q4
+Lap;h8}
+qH
+TailCall_cEqual:g5
+w8:dA
+A=dD
+wB(421,"A[IsLogicalOpcode(A)] "
+wO
+aE,"A"
+,qB1(A)wM);q4
+Lap;}
+}
+m9(115,mA
+aE,"[fp_equal(y,x)]"
+,q81);q4
+Lbi;}
+g8
+0
+hU
+wB(359,m1
+aE,"[x] "
+aE,wN);q4
+Lbj
+qU
+cSqr:wB(361,q41
+wL
+aE,"[x] "
+aE,wN);q4
+Lbj;}
+wB(411,wL
+aE,"cNot"
+,wN);q4
+Lbk;qG
+TailCall_cGreater:g5
+o1:qY
+m9(113,mA
+m2,"[fp_less(x,y)]"
+,q81);q4
+Lbl;qG
+TailCall_cGreaterOrEq:g5
+dK:qY
+m9(114,mA
+aG,"[fp_lessOrEq(x,y)]"
+,q81);q4
+Lbm;qG
+TailCall_cImag:g5
+cImag:qS
+cAbs:wB(81,mV" "
+mZ,"[Value_t()]"
+wH,);q4
+Lbn
+qU
+cReal:wB(80,"cReal "
+mZ,"[Value_t()]"
+wH,);q4
+Lbn
+gY
+wB(192,"x "
+mZ,"[fp_imag(x)]"
+,wN);oS;}
+qH
+TailCall_cInv:g5
+cInv:qY
+if
+hF)){wB(101,a4
+aU,"[Value_t(1)/x]"
+,wN);q4
+Lbp;qG
+TailCall_cLess:g5
+cLess:oL)){A=dE
+wB(301,wJ
+wL
+mJ,mK,qB1(A)wM);q4
+Lbq;}
+}
+m9(111,mA
+mJ,"[fp_less(y,x)]"
+,q81);q4
+Lca;qG
+TailCall_cLessOrEq:g5
+cLessOrEq:qY
+m9(112,mA
+aR,"[fp_lessOrEq(y,x)]"
+,q81);q4
+Lcb;qG
+TailCall_cMax:g5
+cMax
+hH
+wB(60,mX
+mB,,);q4
+w7
+m9(141,mA
+mB,"[fp_max(x,y)]"
+,q81);q4
+Lcc;}
+gP
+cDup:hD
+wB(66,aK
+mQ
+a3
+mB,"B"
+mQ,aI(A)q91(B)wM);q4
+Lbd;qT
+cMax:hD
+wB(68,aK" "
+mB
+a3
+mB,"B "
+mB,aI(A)q91(B)wM);q4
+Lbd;h8}
+qG
+TailCall_cMin:g5
+cMin
+hH
+wB(59,mX
+mC,,);q4
+w7
+m9(140,mA
+mC,"[fp_min(x,y)]"
+,q81);q4
+Lcd;}
+gP
+cDup:hD
+wB(65,aK
+mQ
+a3
+mC,"B"
+mQ,aI(A)q91(B)wM);q4
+Lbd;qT
+cMin:hD
+wB(67,aK" "
+mC
+a3
+mC,"B "
+mC,aI(A)q91(B)wM);q4
+Lbd;h8}
+qG
+TailCall_cMod:g5
+cMod:qY
+if
+hF)){m9(104,aY
+a4"cMod"
+,"[fp_mod(y,x)]"
+,q81);q4
+Lce;}
+qG
+TailCall_cMul:g5
+h3
+hH
+wB(202,"cDup"
+wH,"cSqr"
+,);q4
+Lcf
+oF
+qQ
+h9
+cDup:wB(467,"cDup"
+aA
+wH,"cSqr"
+aA,);q4
+Lcg;oH
+qK
+qO
+A)gA
+oM
+B=hQ
+wB(473,aK
+wH
+a3
+qC1
+wH,m5
+wH
+aA,aI(A)q91(B)wM);q4
+Lch;}
+}
+}
+}
+q4
+dY
+qU
+cPow
+gM
+if
+gF
+h1
+wB(314,mX
+m8
+wH,"[x+Value_t(1)] cPow"
+,wN);q4
+Lci;}
+}
+q4
+dY
+gY
+g8
+gQ
+h3:A=hE
+w0
+wB(93,wS" "
+wZ,wX,qB1(A)wM);q4
+Lcj;}
+q4
+Default3;g7
+Default3:;A=qK
+qR
+IsBinaryOpcode(A)g2
+h2
+qQ
+hE
+qV
+q6:mW(92,aY
+wD,wX,qB1(A)<<","
+a1);q4
+Lck;g7
+B
+g4
+IsBinaryOpcode(B)g2
+B)){qQ
+oC
+qV
+q6:mW(96,aY
+wK,mK,qB1(A)q91(B)<<","
+a1);q4
+Lcl;g7
+C=oC
+qO
+C)){wB(94,"C[IsVarOpcode(C)] "
+wK,mK,qB1(A)q91(B)<<", C"
+wY(C)wM);q4
+Lcm;}
+if(gV
+C)g2
+C)){wB(95,"C[IsUnaryOpcode(C)&&!HasInvalidRangesOpcode(C)] "
+wK,"B "
+mK,qB1(A)q91(B)<<", C"
+wY(C)wM);q4
+Lcn;}
+}
+}
+if(d1
+B)){wB(90,aX
+wD,wX,qB1(A)q91(B)wM);q4
+Lcj;}
+if(gV
+B)g2
+B)){wB(91,"B[IsUnaryOpcode(B)&&!HasInvalidRangesOpcode(B)] "
+wD,mK,qB1(A)q91(B)wM);q4
+Lco;}
+}
+}
+if(d1
+h2
+wB(88,a5" "
+wZ,"[x]"
+,qB1(A)wM);q4
+Lcp;}
+if(gV
+A)g2
+h2
+wB(89,"A[IsUnaryOpcode(A)&&!HasInvalidRangesOpcode(A)] "
+wZ,wX,qB1(A)wM);q4
+Lcq;}
+}
+}
+qQ
+h9
+hS:qQ
+hE
+qV
+cDup:wB(317,aH
+a7,"[x+x]"
+wH,wN);q4
+Lda
+qU
+o5
+3
+qZ
+hO
+A=qL
+4]w0
+wB(386,a5" y"
+wH
+aZ
+a7,wX" A "
+m3
+aZ,wA", "
+aY"= "
+<<y
+qE1(A)wM);q4
+Ldb;}
+w9
+mW(385,aY"cAdd"
+a7,wX" [y*x]"
+aZ,q81);q4
+Ldc;qT
+h3:qQ
+hE
+d3
+3
+h1
+wB(319,aH
+wH
+a7,"cMul [x+x]"
+wH,wN);q4
+Ldd;w9
+hP
+y*oU
+wB(70,"y[y*x==Value_t(1)]"
+wH
+a7,,q81);q4
+Lde;}
+wB(128,"y"
+wH
+a7,m3,q81);q4
+Ldf;qT
+hI
+wB(122,qC1
+a7,mI,wN);q4
+Ldg
+qU
+cSub
+hL
+oM
+if(qL
+3
+qZ
+hO
+A=qL
+4]w0
+wB(387,a5" y"
+wH
+aW
+a7,wX" A "
+m3
+aW,wA", "
+aY"= "
+<<y
+qE1(A)wM);q4
+Ldh;}
+}
+w9
+mW(102,"y"
+a7,"[y*x]"
+,q81);q4
+Ldi;}
+g8
+oG
+wB(55,"x[x==Value_t(1)]"
+wH,,wN);q4
+Lap;}
+g8-oG
+wB(124,"x[x==Value_t(-1)]"
+wH,qC1,wN);q4
+Ldj;}
+g8
+2)){wB(198,"x[x==Value_t(2)]"
+wH,aH,wN);q4
+Ldk;h8
+g7
+dY:;A=dF
+qO
+A
+gQ
+h3:qQ
+hE
+qV
+hI
+B=hQ
+wB(470,aK
+aA
+wH" "
+wS,m5
+wH
+aA,aI(A)q91(B)wM);q4
+Lch;}
+q4
+Default4;g7
+Default4:;hD
+wB(461,aK
+wH" "
+wS,m5
+wH,aI(A)q91(B)wM);q4
+Ldl;}
+}
+q4
+dZ
+oF
+hD
+wB(464,aK
+aA" "
+wS,m5
+aA,aI(A)q91(B)wM);q4
+Lcg;}
+q4
+dZ;g7
+dZ:;B=qK
+qR
+w4
+wB(458,aK" "
+wS,m5,aI(A)q91(B)wM);q4
+Lcf;}
+}
+}
+if(gV
+h2
+B=qK
+qO
+B
+qP
+1
+gA
+oM
+C=oC
+qR
+C==A){D=qL
+4]qR
+D==B){wB(477,"D[D==B] C[C==A]"
+wH" B[IsVarOpcode(B)&&mData->mByteCode.size()>1] A[IsUnaryOpcode(A)]"
+wH,"D C cSqr"
+wH,aI(A)q91(B)<<", C"
+wY(C)<<", D"
+wY(D)wM);q4
+Ldm;}
+}
+}
+}
+qG
+TailCall_cNEqual:g5
+cNEqual:dA
+A=dD
+wB(422,"A[IsLogicalOpcode(A)] "
+wO
+wW,"A"
+a0,qB1(A)wM);q4
+Lbk;}
+}
+m9(116,mA
+wW,"[fp_nequal(y,x)]"
+,q81);q4
+Ldn;}
+g8
+0
+hU
+wB(360,m1
+wW,"[x] "
+wW,wN);q4
+Ldo
+qU
+cSqr:wB(362,q41
+wL
+wW,"[x] "
+wW,wN);q4
+Ldo;}
+wB(412,wL
+wW,aJ,wN);q4
+Ldp;qG
+TailCall_cNeg:g5
+hI
+qS
+h3
+gM
+wB(123,"x"
+wH
+aA,mI,wN);q4
+Ldq;qT
+hI
+wB(61,qC1
+aA,,);q4
+w7
+wB(100,"x"
+aA,"[-x]"
+,wN);q4
+Lea;}
+qH
+TailCall_cNot:g5
+cNot:qS
+cAbsNotNot:wB(231,"cAbsNotNot"
+a0,aS,);q4
+Leb
+qU
+hS
+gM
+wB(424,aF
+a0,"[-x] "
+aE,wN);q4
+Lec;qT
+w8:wB(220,aE
+a0,wW,);q4
+Led
+qU
+o1:wB(218,m2
+a0,aR,);q4
+Lee
+qU
+dK:wB(219,aG
+a0,mJ,);q4
+Lef
+qU
+cLess:wB(216,mJ
+a0,aG,);q4
+Leg
+qU
+cLessOrEq:wB(217,aR
+a0,m2,);q4
+Leh
+qU
+cNEqual:wB(221,wW
+a0,aE,);q4
+Lei
+qU
+cNot:wB(229,"cNot"
+a0,aJ,);q4
+Lbb
+qU
+dS:wB(230,aJ
+a0,"cNot"
+,);q4
+Lej
+gY
+wB(107,"x"
+a0,"[fp_not(x)]"
+,wN);q4
+Lek;}
+qH
+TailCall_cNotNot:g5
+dS:qS
+hS
+gM
+wB(423,aF" "
+aJ,"[-x] "
+wW,wN);q4
+Lel;qT
+cNot:wB(232,"cNot "
+aJ,"cNot"
+,);gJ}
+qH
+TailCall_cOr:g5
+cOr
+hH
+wB(223,mX"cOr"
+,aJ,);q4
+Lbb
+gY
+m9(118,mA"cOr"
+,"[fp_or(x,y)]"
+,q81);q4
+Lem;h8}
+qH
+TailCall_cRDiv:g5
+cRDiv:dA
+wB(268,wO"cRDiv"
+,aU,wN);q4
+Len;qG
+TailCall_cRSub:g5
+cRSub
+d4
+q0[0
+h1
+wB(77,"cDup"
+mE,"[Value_t()]"
+wH,);q4
+Lbn;}
+qH
+TailCall_cReal:g5
+cReal:qY
+wB(191,"x cReal"
+,"[fp_real(x)]"
+,wN);q4
+Leo;}
+qH
+TailCall_cSqr:g5
+cSqr:qS
+cAbs:wB(204,mV" cSqr"
+,"cSqr"
+,);q4
+Lep
+oF
+wB(203,m0"cSqr"
+,"cSqr"
+,);q4
+Lep;}
+qH
+TailCall_cSub:g5
+cSub
+hH
+wB(76,"cDup"
+aW,"[Value_t()]"
+wH,);q4
+Lbn
+oF
+wB(200,qC1
+aW,"cAdd"
+,);q4
+Leq
+gY
+g8)){wB(58,"x[x==Value_t()]"
+aW,,wN);q4
+Lap;}
+m9(106,aY"x"
+aW,"[y-x]"
+,q81);q4
+Lfa;}
+wB(51,"x"
+aW,"[-x]"
+aZ,wN);q4
+Lfb
+gR
+w0
+oY
+cRSub
+dV
+wB(289,"x"
+mE
+a3"cSub"
+,"A"
+aZ" [x]"
+mE,aI(A)qD1
+wM);q4
+Lfc;}
+wB(296,a6
+a3"cSub"
+,"[DO_STACKPLUS1] A"
+aW
+mE,aI(A)wM);incStackPtr();--mStackPtr;q4
+Lfd;}
+qG
+g7
+Default0:;A=w5
+w1
+0){B=q0[0
+hZ
+wB(475,aK" A[IsVarOpcode(A)&&mData->mByteCode.size()>0]"
+,"B"
+mQ,aI(A)q91(B)wM);q4
+Lfe;}
+}
+if(gV
+h2
+B=dF
+qO
+B
+qP
+1){C=qK
+qR
+C==A){D
+g4
+D==B){wB(476,"D[D==B] C[C==A] B[IsVarOpcode(B)&&mData->mByteCode.size()>1] A[IsUnaryOpcode(A)]"
+,"D C"
+mQ,aI(A)q91(B)<<", C"
+wY(C)<<", D"
+wY(D)wM);q4
+Lff;}
+}
+}
+}
+}
+q4
+Laa;Laa:qW
+w5);gJ
+Lab:g6
+wE(cAbs);q4
+TailCall_cAbs;Lac:q7=dP;gJ
+Lad:oZ
+4));gG
+Lfg:w5=h3;Lfh:g0
+Lfi:wE(cMul);q4
+TailCall_cMul;Lae:hV
+4
+dT
+oZ
+4)q71
+gX
+Lfg;Laf:q7=x+g1
+1);gG
+Lbq:w5=h3;q4
+Lfi;Lag:gU
+cSub;Lfj:wE(cSub);q4
+TailCall_cSub;Lah:hW
+2
+gH
+Lfk:g0
+Lfl:wE(cAdd);q4
+TailCall_cAdd;Lai:hW
+oR
+Lfm:qE
+hS);Lfn:w5=cRSub;g0
+wE(cRSub);q4
+TailCall_cRSub;Laj:o9;qL
+2
+gK
+q4
+Lfm;Lak:hW
+2
+gH
+q4
+Lfn;Lal:hW
+4
+gH
+Lfo:qE
+hS);Lfp:qE
+B);Lfq:w5=cSub;g0
+q4
+Lfj;Lam:o9;oC=q6
+q9
+oR
+q4
+Lfo;Lan:hW
+oR
+q4
+Lfp;Lao:gT
+y+x;Lap:qM
+Lbd:q5
+gJ
+Laq:q8
+oV
+o7
+x
+q71
+gX
+Lfm;Lba:mM
+A
+gX
+Lfm;Lbb:gU
+dS;Lga:wE(cNotNot);q4
+TailCall_cNotNot;Lbc:gT
+fp_and(x
+h6
+Lbe:q7=fp_conj
+m6
+Lbf:oZ));dF
+dJ
+qE
+dU
+oZ
+1));Lgb:qW
+q6);Lgc:w5=hS;q4
+Lfk;Lbg:o9;dI
+wE(cDiv);q4
+TailCall_cDiv;Lbh:gT
+y/x;q4
+Lap;Lbi:gT
+fp_equal
+mO
+Lbj:dI
+Lgd:wE(cEqual);q4
+TailCall_cEqual;Lbk:qM
+q5
+w5=cNot;g0
+Lge:wE(cNot);q4
+TailCall_cNot;Lbl:gT
+fp_less(x
+h6
+Lbm:gT
+fp_lessOrEq(x
+h6
+Lbn:oZ));dF
+dJ
+q4
+Lfg;Lbo:q7=fp_imag
+m6
+Lbp:q7=g1
+1)/x;gJ
+Lca:gT
+fp_less
+mO
+Lcb:gT
+fp_lessOrEq
+mO
+Lcc:gT
+fp_max(x
+h6
+Lcd:gT
+fp_min(x
+h6
+Lce:gT
+fp_mod
+mO
+Lcf:gU
+cSqr;Lgf:wE(cSqr);q4
+TailCall_cSqr;Lcg:mM
+cSqr);Lgg:w5=cNeg;g0
+wE(cNeg);q4
+TailCall_cNeg;Lch:hV
+3
+gC
+cSqr);dM
+Lgg;Lci:q7=x+g1
+1);hE=q6
+q9
+2
+gC
+cPow);gJ
+Lcj:gG
+q4
+Lfi;Lck:gT
+x;Lgh:dG
+Lfh;Lcl:qF1
+qM
+Lgi:hV
+4
+gH
+Lgj:o6
+x);Lgk:qW
+q6
+gX
+Lfh;Lcm:qM
+q4
+Lgi;Lcn:q8
+4
+gC
+B
+gX
+Lgj;Lco:q8
+oR
+q4
+Lgj;Lcp:qK
+dJ
+q4
+Lbd;Lcq:dI
+q4
+Lfi;Lda:q7=x+x;q4
+Lcj;Ldb:gT
+x;qL
+4]dJ
+q8
+4
+dT
+o6
+y*x
+q71);dM
+Lgc;Ldc:gT
+x;d7
+dU
+qF
+y*x
+gX
+Lgb;Ldd:q8
+4
+dT
+qF
+x+x
+gX
+Lgk;Lde:qF1
+q8
+oR
+gJ
+Ldf:qG1
+q4
+Lgh;Ldg:o9;q4
+Lcq;Ldh:gT
+x;qL
+4]dJ
+q8
+4
+dT
+o6
+y*x
+q71);dM
+Lfq;Ldi:qG1
+q4
+Lap;Ldj:qM
+w3
+Lgg;Ldk:dF=cDup;dW-=1;qM
+Lgl:w5=hS;q4
+Lfl;Ldl:hV
+2
+gH
+Lgm:qE
+cSqr
+gX
+Lfh;Ldm:hV
+oR
+q4
+Lgm;Ldn:gT
+fp_nequal
+mO
+Ldo:dI
+Lgn:wE(cNEqual);q4
+TailCall_cNEqual;Ldp:qM
+q5
+w5=dS;g0
+q4
+Lga;Ldq:o9;g6
+q4
+Lbq;Lea:o9;gJ
+Leb:q1
+cAbsNot);gJ
+Lec:o9;Lei:gU
+w8;q4
+Lgd;Led:gU
+cNEqual;q4
+Lgn;Lee:gU
+cLessOrEq;wE(cLessOrEq);q4
+TailCall_cLessOrEq;Lef:gU
+cLess;wE(cLess);q4
+TailCall_cLess;Leg:gU
+dK;wE(cGreaterOrEq);q4
+TailCall_cGreaterOrEq;Leh:gU
+o1;wE(cGreater);q4
+TailCall_cGreater;Lej:g6
+q4
+Lge;Lek:q7=fp_not
+m6
+Lel:o9;q4
+Led;Lem:gT
+fp_or(x
+h6
+Len:qM
+q5
+w5=cInv;g0
+wE(cInv);q4
+TailCall_cInv;Leo:q7=fp_real
+m6
+Lep:g6
+q4
+Lgf;Leq:g6
+q4
+Lgl;Lfa:gT
+y-x;q4
+Lap;Lfb:o9;q4
+Lgl;Lfc:q8
+oV
+oJ
+hS
+o7
+x
+q71
+gX
+Lfn;Lfd:mM
+A
+oJ
+cSub
+gX
+Lfn;Lfe:qW
+cDup);gJ
+Lff:dF=cDup;gJ
+gJ
+q4
+TailCall_cAnd;q4
+TailCall_cConj;q4
+TailCall_cImag;q4
+TailCall_cMax;q4
+TailCall_cMin;q4
+TailCall_cMod;q4
+TailCall_cNeg;q4
+TailCall_cOr;q4
+TailCall_cRDiv;q4
+TailCall_cReal;q4
+TailCall_cSub;
+#endif
+#if((FP_FLOAT_VERSION) && !(FP_COMPLEX_VERSION))
+dH
+x;hT
+A;dH
+gE
+C;hT
+D;qQ
+w5){TailCall_cAbs:g5
+cAbs:qS
+h0
+oH
+dF
+qR
+qX
+wB(393,wJ
+mV,"A"
+,aI(A)wM);gJ
+qG
+TailCall_cAcos:g5
+cAcos:hN<=m7(148,"x[fp_abs(x)<=Value_t(1)] cAcos"
+,"[fp_acos(x)]"
+,wN);q4
+Lad;qG
+TailCall_cAcosh:g5
+cAcosh:qY
+if(x>=m7(145,"x[x>=Value_t(1)] cAcosh"
+,"[fp_acosh(x)]"
+,wN);q4
+Lae;qG
+TailCall_cAdd:g5
+hG
+Laf;qT
+h3
+hL]==hS){if(qL
+gZ
+Lag;}
+h8}
+q4
+dX
+qU
+d2
+gF
+h1
+wB(313,"cDup"
+a7
+aZ,"[x+Value_t(1)]"
+wH,wN);q4
+Lah;}
+}
+q4
+dX
+oF
+wB(199,qC1
+aZ,"cSub"
+,);q4
+Lai
+gY
+hK
+qZ
+mW(127,aY"cAdd"
+mD,"[y+x]"
+aZ,q81);q4
+Laj;qT
+cRSub:qQ
+hE
+d3
+3
+qZ
+mW(298,aY"cAdd"
+mE
+mD,mN
+aZ
+mE,q81);q4
+Lak;qT
+hI
+wB(299,m0
+a6
+mD,"[-x]"
+aZ
+mE,wN);q4
+Lal
+qU
+q6:mW(297,aY
+a6
+mD,mN
+mE,q81);q4
+Lam;qT
+oA
+Lan;qT
+hI
+wB(293,m0"B[IsVarOpcode(B)]"
+aW
+mD,"[-x]"
+aZ" B"
+aW,wA","
+a8(B)wM);q4
+Lao
+qU
+q6:mW(291,aY"B[IsVarOpcode(B)]"
+aW
+mD,mN" B"
+aW,wA","
+a8(B)<<","
+a1);q4
+Lap;}
+w9
+mW(105,aY
+aF,"[y+x]"
+,q81);q4
+Laq;}
+g8)){wB(57,"x[x==Value_t()]"
+aZ,,wN);q4
+Lba;h8
+g7
+dX:;A=dF
+w0
+oY
+cRSub
+dV
+wB(290,"x"
+mE
+a3"cAdd"
+,"[DO_STACKPLUS1] A [x]"
+aZ
+mE,aI(A)qD1
+wM);incStackPtr();--mStackPtr;q4
+Lbb;}
+wB(295,a6
+a3"cAdd"
+,"[DO_STACKPLUS1] A"
+aZ
+mE,aI(A)wM);incStackPtr();--mStackPtr;q4
+Lbc;}
+qG
+TailCall_cAnd:g5
+cAnd
+hH
+wB(224,mX"cAnd"
+,aJ,);q4
+w7
+m9(117,mA"cAnd"
+,"[fp_and(x,y)]"
+,q81);q4
+Lbe;h8}
+qH
+TailCall_cAsin:g5
+cAsin:hN<=m7(149,"x[fp_abs(x)<=Value_t(1)] cAsin"
+,"[fp_asin(x)]"
+,wN);q4
+Lbf;qG
+TailCall_cAsinh:g5
+cAsinh:qY
+wB(146,"x cAsinh"
+,"[fp_asinh(x)]"
+,wN);q4
+Lbg;}
+qH
+TailCall_cAtan:g5
+cAtan:qY
+wB(150,"x cAtan"
+,"[fp_atan(x)]"
+,wN);q4
+Lbh;}
+qH
+TailCall_cAtan2:g5
+cAtan2:qY
+m9(139,mA"cAtan2"
+,"[fp_atan2(y,x)]"
+,q81);q4
+Lbi;qG
+TailCall_cAtanh:g5
+cAtanh:hN<m7(147,"x[fp_abs(x)<Value_t(1)] cAtanh"
+,"[fp_atanh(x)]"
+,wN);q4
+Lbj;qG
+TailCall_cCbrt:g5
+cCbrt:qY
+wB(151,"x cCbrt"
+,"[fp_cbrt(x)]"
+,wN);q4
+Lbk;}
+qH
+TailCall_cCeil:g5
+cCeil:qS
+hI
+wB(402,m0
+q01,mS
+aA,);q4
+Lbl
+gY
+wB(135,"x "
+q01,"[fp_ceil(x)]"
+,wN);q4
+Lbm
+gS
+wB(396,"A[IsAlwaysIntegerOpcode(A)] "
+q01,"A"
+,aI(A)wM);gJ
+qG
+TailCall_cCos:g5
+cCos:qS
+cAbs:wB(235,mV" "
+aO,aO,);q4
+Lbn
+oF
+wB(238,m0
+aO,aO,);q4
+Lbn
+gY
+wB(152,"x "
+aO,"[fp_cos(x)]"
+,wN);oS;oH
+qN
+qQ
+h9
+cSec:hD
+wB(500,aK" cSec "
+wI
+aO,"B cSec "
+aT,aI(A)q91(B)wM);q4
+Lbp;qT
+cSin:hD
+wB(494,aK" "
+mP" "
+wI
+aO,"B cSinCos"
+,aI(A)q91(B)wM);q4
+Lbq;h8}
+qG
+TailCall_cCosh:g5
+cCosh:qS
+cAbs:wB(236,mV" "
+aM,aM,);q4
+Lca
+qU
+cAsinh:wB(450,"cAsinh "
+aM,"[DO_STACKPLUS1] "
+q41"[Value_t(1)] "
+aQ,);incStackPtr();--mStackPtr;q4
+Lcb
+oF
+wB(239,m0
+aM,aM,);q4
+Lca
+gY
+wB(153,"x "
+aM,"[fp_cosh(x)]"
+,wN);q4
+Lcc;oH
+qN
+oY
+cSinh
+q11(507,aK" cSinh "
+wI
+aM,"B cSinhCosh"
+,aI(A)q91(B)wM);q4
+Lcd;}
+}
+qG
+TailCall_cCot:g5
+cCot:A=qN
+oY
+cTan
+q11(498,aK" "
+mR" "
+wI"cCot"
+,"B "
+mR" "
+aT,aI(A)q91(B)wM);q4
+Lbp;}
+qG
+TailCall_cCsc:g5
+cCsc:A=qN
+oY
+cSin
+q11(496,aK" "
+mP" "
+wI"cCsc"
+,"B "
+mP" "
+aT,aI(A)q91(B)wM);q4
+Lbp;}
+qG
+TailCall_cDeg:g5
+cDeg:qY
+wB(133,"x cDeg"
+,"[RadiansToDegrees(x)]"
+,wN);q4
+Lce;}
+qH
+TailCall_cDiv:g5
+cDiv:qS
+cCos:wB(250,aO
+mF,"cSec"
+wH,);q4
+Lcf
+qU
+cCot:wB(254,"cCot"
+mF,mR
+wH,);q4
+Lcg
+qU
+cCsc:wB(252,"cCsc"
+mF,mP
+wH,);q4
+Lch
+qU
+cDup:wB(78,"cDup"
+mF,"[Value_t()]"
+wH" [Value_t(1)]"
+aZ,);q4
+Lci
+qU
+w2
+wB(408,"cExp"
+mF,m0"cExp"
+wH,);q4
+Lcj
+qU
+cExp2:wB(409,"cExp2"
+mF,m0"cExp2"
+wH,);q4
+Lck
+qU
+cInv:wB(213,aU
+mF,"cMul"
+,);q4
+Lcl
+qU
+cPow:wB(407,"cPow"
+mF,m0"cPow"
+wH,);q4
+Lcm
+qU
+cSec:wB(253,"cSec"
+mF,aO
+wH,);q4
+Lcn
+qU
+cSin:wB(249,mP
+mF,"cCsc"
+wH,);q4
+Lco
+qU
+cSinCos:wB(502,"cSinCos"
+mF,mR,);q4
+Lcp
+qU
+cSinhCosh:wB(509,"cSinhCosh"
+mF,"cTanh"
+,);q4
+Lcq
+qU
+cTan:wB(251,mR
+mF,"cCot"
+wH,);q4
+Lda
+gY
+if
+hF
+gQ
+hI
+wB(125,m0
+a4"cDiv"
+,"[-x]"
+mF,wN);q4
+Ldb
+qU
+q6:mW(103,aY
+a4"cDiv"
+,"[y/x]"
+,q81);q4
+Ldc;}
+}
+g8
+oG
+wB(56,wO"cDiv"
+,,wN);q4
+Lba;}
+dB
+h3
+gA
+qZ
+hP(y/x)==fp_const_rad_to_deg
+h7
+wB(321,"y[(y/x)==fp_const_rad_to_deg<Value_t>()]"
+wH" "
+wR,"cDeg"
+,q81);q4
+Ldd;}
+if((y/x)==fp_const_deg_to_rad
+h7
+wB(322,"y[(y/x)==fp_const_deg_to_rad<Value_t>()]"
+wH" "
+wR,"cRad"
+,q81);q4
+Lde;}
+wB(323,"y"
+wH" "
+wR,"[y/x]"
+wH,q81);q4
+Ldf;}
+}
+wB(325,wR,"[Value_t(1)/x]"
+wH,wN);q4
+Ldg;}
+gP
+cDiv:hC
+wB(271,aX"cDiv "
+wV,"[DO_STACKPLUS1] B A"
+wH
+mF,aI(A)q91(B)wM);incStackPtr();--mStackPtr;q4
+Ldh;qT
+cRDiv:qQ
+hE
+qV
+hM
+wB(266,"x"
+a9" "
+wV,"A"
+wH" [x]"
+a9,aI(A)qD1
+wM);q4
+Ldi;g7
+hC
+wB(265,"B[IsVarOpcode(B)]"
+a9" "
+wV,"A"
+wH" B"
+a9,aI(A)q91(B)wM);q4
+Ldj;}
+h8}
+qG
+TailCall_cEqual:g5
+w8:oL
+hU
+wB(359,m1
+aE,"[x] "
+aE,wN);q4
+Ldk
+qU
+cSqr:wB(361,q41
+wL
+aE,"[x] "
+aE,wN);q4
+Ldk;}
+}
+m9(115,mA
+aE,"[fp_equal(y,x)]"
+,q81);q4
+Ldl;qG
+TailCall_cExp:g5
+w2
+qS
+hS
+gM
+wB(404,aF
+mL,q21"[fp_exp(x)]"
+wH,wN);q4
+Ldm;qT
+cLog:A=dE
+wB(340,wJ
+mG
+mL,"A"
+,aI(A)wM);q4
+oN
+hM
+wB(154,"x"
+mL,"[fp_exp(x)]"
+,wN);q4
+Ldo;}
+qH
+TailCall_cExp2:g5
+cExp2:qS
+hS
+gM
+wB(405,aF
+q31,"cExp2 [fp_exp2(x)]"
+wH,wN);q4
+Ldp;qT
+cLog2:A=dE
+wB(341,wJ
+aN
+q31,"A"
+,aI(A)wM);q4
+oN
+hM
+wB(155,"x"
+q31,"[fp_exp2(x)]"
+,wN);q4
+Ldq;}
+wB(479,"cExp2"
+,"[DO_STACKPLUS1] [fp_log(Value_t(2))]"
+wH
+mL,);incStackPtr();--mStackPtr;q4
+Lea;TailCall_cFloor:g5
+cFloor:qS
+hI
+wB(401,m0
+mS,q01
+aA,);q4
+Leb
+gY
+wB(136,"x "
+mS,"[fp_floor(x)]"
+,wN);q4
+Lec
+gS
+wB(395,"A[IsAlwaysIntegerOpcode(A)] "
+mS,"A"
+,aI(A)wM);gJ
+qG
+TailCall_cGreater:g5
+o1:qY
+m9(113,mA
+m2,"[fp_less(x,y)]"
+,q81);q4
+Led;}
+g8-oO
+wB(431,"x[x==Value_t(-0.5)] "
+m2,m0
+aS,wN);q4
+Lee;qG
+TailCall_cGreaterOrEq:g5
+dK:qY
+dB
+cAbs){wB(427,mV" x[x!=Value_t(0)] "
+aG,"[Value_t(0.5)/x]"
+wH" "
+aJ,wN);q4
+Lef;}
+}
+m9(114,mA
+aG,"[fp_lessOrEq(x,y)]"
+,q81);q4
+Leg;}
+g8
+oO
+wB(430,"x[x==Value_t(0.5)] "
+aG,"cAbsNotNot"
+,wN);q4
+Leh;qG
+TailCall_cHypot:g5
+cHypot
+d4
+dF==cSinCos){wB(84,"cSinCos cHypot"
+,"[Value_t()]"
+wH" [Value_t(1)]"
+aZ,);q4
+Lci;}
+qH
+TailCall_cInt:g5
+cInt:qS
+hM
+wB(137,"x cInt"
+,"[fp_int(x)]"
+,wN);q4
+Lei
+gS
+wB(397,"A[IsAlwaysIntegerOpcode(A)] cInt"
+,"A"
+,aI(A)wM);gJ
+qG
+TailCall_cInv:g5
+cInv:qS
+cCos:wB(256,aO" "
+aU,"cSec"
+,);q4
+Lej
+qU
+cCot:wB(260,"cCot "
+aU,mR,);q4
+Lcp
+qU
+cCsc:wB(258,"cCsc "
+aU,mP,);q4
+Lek
+qU
+cInv:wB(62,aU" "
+aU,,);q4
+Ldn
+qU
+cPow:wB(355,q61
+aU,m0"cPow"
+,);q4
+Lel
+qU
+cSec:wB(259,"cSec "
+aU,aO,);q4
+Lem
+qU
+cSin:wB(255,mP" "
+aU,"cCsc"
+,);q4
+Len
+qU
+cSqrt:wB(206,q51" "
+aU,"cRSqrt"
+,);q4
+Leo
+qU
+cTan:wB(257,mR" "
+aU,"cCot"
+,);q4
+Lep
+gY
+if
+hF)){wB(101,a4
+aU,"[Value_t(1)/x]"
+,wN);q4
+Leq;h8}
+qH
+TailCall_cLess:g5
+cLess:oL)){A=dE
+wB(301,wJ
+wL
+mJ,mK,qB1(A)wM);q4
+Lfa;}
+}
+dB
+cAbs){wB(426,mV" x[x!=Value_t(0)] "
+mJ,"[Value_t(0.5)/x]"
+wH
+a0,wN);q4
+Lfb;}
+}
+m9(111,mA
+mJ,"[fp_less(y,x)]"
+,q81);q4
+Lfc;}
+g8
+oO
+wB(429,"x[x==Value_t(0.5)] "
+mJ,aS,wN);q4
+Lfd;qG
+TailCall_cLessOrEq:g5
+cLessOrEq:qY
+m9(112,mA
+aR,"[fp_lessOrEq(y,x)]"
+,q81);q4
+Lfe;}
+g8-oO
+wB(432,"x[x==Value_t(-0.5)] "
+aR,m0"cAbsNotNot"
+,wN);q4
+Lff;qG
+TailCall_cLog:g5
+cLog:mT(343,q21
+mG,,);q4
+Ldn
+qU
+gL
+wB(491,mU
+mG,mG" [fp_log(x)]"
+aZ,wN);q4
+Lfg;}
+o2
+wB(303,q41
+mG,mV" "
+mG" "
+aH,);q4
+Lfh
+aV(156,wQ" "
+mG,"[fp_log(x)]"
+,wN);q4
+Lfi;h8}
+qH
+TailCall_cLog10:g5
+cLog10:mT(481,q21
+aL,"[DO_STACKPLUS1] [fp_log10(fp_const_e<Value_t>())]"
+wH,);incStackPtr();--mStackPtr;q4
+Lfj
+qU
+gL
+wB(492,mU
+aL,aL" [fp_log10(x)]"
+aZ,wN);q4
+Lfk;}
+o2
+wB(305,q41
+aL,mV" "
+aL" "
+aH,);q4
+Lfl
+aV(157,wQ" "
+aL,"[fp_log10(x)]"
+,wN);q4
+Lfm;h8}
+qH
+TailCall_cLog2:g5
+cLog2:mT(480,q21
+aN,"[DO_STACKPLUS1] [fp_log2(fp_const_e<Value_t>())]"
+wH,);incStackPtr();--mStackPtr;q4
+Lfn
+qU
+cExp2:wB(344,"cExp2 "
+aN,,);q4
+Ldn
+qU
+gL
+wB(490,mU
+aN,aN" [fp_log2(x)]"
+aZ,wN);q4
+Lfo;}
+o2
+wB(304,q41
+aN,mV" "
+aN" "
+aH,);q4
+Lfp
+aV(158,wQ" "
+aN,"[fp_log2(x)]"
+,wN);q4
+Lfq;h8}
+qH
+TailCall_cMax:g5
+cMax
+hH
+wB(60,mX
+mB,,);q4
+Ldn
+gY
+m9(141,mA
+mB,"[fp_max(x,y)]"
+,q81);q4
+Lga;}
+gP
+cDup:hD
+wB(66,aK
+mQ
+a3
+mB,"B"
+mQ,aI(A)q91(B)wM);q4
+oN
+cMax:hD
+wB(68,aK" "
+mB
+a3
+mB,"B "
+mB,aI(A)q91(B)wM);q4
+Ldn;h8}
+qG
+TailCall_cMin:g5
+cMin
+hH
+wB(59,mX
+mC,,);q4
+Ldn
+gY
+m9(140,mA
+mC,"[fp_min(x,y)]"
+,q81);q4
+Lgb;}
+gP
+cDup:hD
+wB(65,aK
+mQ
+a3
+mC,"B"
+mQ,aI(A)q91(B)wM);q4
+oN
+cMin:hD
+wB(67,aK" "
+mC
+a3
+mC,"B "
+mC,aI(A)q91(B)wM);q4
+Ldn;h8}
+qG
+TailCall_cMod:g5
+cMod:qY
+if
+hF)){m9(104,aY
+a4"cMod"
+,"[fp_mod(y,x)]"
+,q81);q4
+Lgc;}
+qG
+TailCall_cMul:g5
+h3:qS
+cCsc:A=qK
+w1
+3
+gA]==cCos){B=hQ
+wB(508,aK" "
+aO" A[IsVarOpcode(A)&&mData->mByteCode.size()>3] cCsc"
+wH,"B cCot"
+,aI(A)q91(B)wM);q4
+Lgd;}
+}
+}
+q4
+dY
+qU
+cDup:wB(202,"cDup"
+wH,"cSqr"
+,);q4
+Lge
+qU
+cInv:wB(214,aU
+wH,"cDiv"
+,);q4
+Lgf
+oF
+qQ
+h9
+cDup:wB(467,"cDup"
+aA
+wH,"cSqr"
+aA,);q4
+Lgg;oH
+qK
+qO
+A)gA
+oM
+B=hQ
+wB(473,aK
+wH
+a3
+qC1
+wH,m5
+wH
+aA,aI(A)q91(B)wM);q4
+Lgh;}
+}
+}
+}
+q4
+dY
+qU
+cPow
+gM
+if
+gF
+h1
+wB(314,mX
+m8
+wH,"[x+Value_t(1)] cPow"
+,wN);q4
+Lgi;}
+}
+q4
+dY
+gY
+g8
+gQ
+h3:A=hE
+w0
+wB(93,wS" "
+wZ,wX,qB1(A)wM);q4
+Lgj;}
+q4
+Default3;g7
+Default3:;A=qK
+qR
+IsBinaryOpcode(A)g2
+h2
+qQ
+hE
+qV
+q6:mW(92,aY
+wD,wX,qB1(A)<<","
+a1);q4
+Lgk;g7
+B
+g4
+IsBinaryOpcode(B)g2
+B)){qQ
+oC
+qV
+q6:mW(96,aY
+wK,mK,qB1(A)q91(B)<<","
+a1);q4
+Lgl;g7
+C=oC
+qO
+C)){wB(94,"C[IsVarOpcode(C)] "
+wK,mK,qB1(A)q91(B)<<", C"
+wY(C)wM);q4
+Lgm;}
+if(gV
+C)g2
+C)){wB(95,"C[IsUnaryOpcode(C)&&!HasInvalidRangesOpcode(C)] "
+wK,"B "
+mK,qB1(A)q91(B)<<", C"
+wY(C)wM);q4
+Lgn;}
+}
+}
+if(d1
+B)){wB(90,aX
+wD,wX,qB1(A)q91(B)wM);q4
+Lgj;}
+if(gV
+B)g2
+B)){wB(91,"B[IsUnaryOpcode(B)&&!HasInvalidRangesOpcode(B)] "
+wD,mK,qB1(A)q91(B)wM);q4
+Lgo;}
+}
+}
+if(d1
+h2
+wB(88,a5" "
+wZ,"[x]"
+,qB1(A)wM);q4
+Lgp;}
+if(gV
+A)g2
+h2
+wB(89,"A[IsUnaryOpcode(A)&&!HasInvalidRangesOpcode(A)] "
+wZ,wX,qB1(A)wM);q4
+Lgq;}
+}
+}
+qQ
+h9
+hS:qQ
+hE
+qV
+cDup
+d4
+x+oU
+wB(316,"cDup[x+x==Value_t(1)]"
+aZ
+a7,,wN);q4
+Lha;}
+wB(317,aH
+a7,"[x+x]"
+wH,wN);q4
+Lhb
+qU
+o5
+3
+qZ
+hO
+A=qL
+4]w0
+wB(386,a5" y"
+wH
+aZ
+a7,wX" A "
+m3
+aZ,wA", "
+aY"= "
+<<y
+qE1(A)wM);q4
+Lhc;}
+w9
+mW(385,aY"cAdd"
+a7,wX" [y*x]"
+aZ,q81);q4
+Lhd;qT
+cDeg:wB(209,"cDeg"
+a7,"[RadiansToDegrees(x)]"
+wH,wN);q4
+Lhe
+qU
+cDiv
+oB
+qV
+o5
+4
+qZ
+mW(278,"y"
+wH" "
+aX
+mH,m3
+qH1,wA","
+a8(B)<<","
+a1);q4
+Lhf;qT
+hI
+wB(279,m0
+aX
+mH,mI
+qH1,wA","
+a8(B)wM);q4
+Lhg
+qU
+q6:mW(277,aY
+aX
+mH,"[y*x] B"
+mF,wA","
+a8(B)<<","
+a1);q4
+Lhh;}
+qT
+h3:qQ
+hE
+d3
+3
+h1
+if(x+oU
+wB(318,"cDup[x+x==Value_t(1)]"
+aZ
+wH
+a7,"cMul"
+,wN);q4
+Lhi;}
+wB(319,aH
+wH
+a7,"cMul [x+x]"
+wH,wN);q4
+Lhj;w9
+hP
+y*oU
+wB(70,"y[y*x==Value_t(1)]"
+wH
+a7,,q81);q4
+Lhk;}
+if((y*x)==fp_const_rad_to_deg
+h7
+wB(307,"y[(y*x)==fp_const_rad_to_deg<Value_t>()]"
+wH
+a7,"cDeg"
+,q81);q4
+Ldd;}
+if((y*x)==fp_const_deg_to_rad
+h7
+wB(308,"y[(y*x)==fp_const_deg_to_rad<Value_t>()]"
+wH
+a7,"cRad"
+,q81);q4
+Lde;}
+wB(128,"y"
+wH
+a7,m3,q81);q4
+Lhl;qT
+hI
+wB(122,qC1
+a7,mI,wN);q4
+Lhm
+qU
+cRDiv:qQ
+hE
+qV
+o5
+3
+qZ
+mW(285,"y"
+wH
+a9
+a7,m3
+a9,q81);q4
+Lhn;qT
+hI
+wB(286,qC1
+a9
+a7,mI
+a9,wN);q4
+Lho
+qU
+q6:mW(284,"y"
+a9
+a7,"[y*x]"
+a9,q81);q4
+Lhp;qT
+cRad:wB(210,"cRad"
+a7,"[DegreesToRadians(x)]"
+wH,wN);q4
+Lhq
+qU
+cSub
+hL
+oM
+if(qL
+3
+qZ
+hO
+A=qL
+4]w0
+wB(387,a5" y"
+wH
+aW
+a7,wX" A "
+m3
+aW,wA", "
+aY"= "
+<<y
+qE1(A)wM);q4
+Lia;}
+}
+w9
+mW(102,"y"
+a7,"[y*x]"
+,q81);q4
+Lib;}
+g8
+oG
+wB(55,"x[x==Value_t(1)]"
+wH,,wN);q4
+Lba;}
+g8-oG
+wB(124,"x[x==Value_t(-1)]"
+wH,qC1,wN);q4
+Lic;}
+g8
+2)){wB(198,"x[x==Value_t(2)]"
+wH,aH,wN);q4
+Lid;}
+if(x==fp_const_rad_to_deg
+h7
+wB(207,"x[x==fp_const_rad_to_deg<Value_t>()]"
+wH,"cDeg"
+,wN);q4
+Lie;}
+if(x==fp_const_deg_to_rad
+h7
+wB(208,"x[x==fp_const_deg_to_rad<Value_t>()]"
+wH,"cRad"
+,wN);q4
+Lif;h8
+g7
+dY:;A=dF
+qO
+A
+gQ
+cDiv:hC
+wB(274,aX"cDiv "
+wS,"[DO_STACKPLUS1] A"
+wH
+qH1,aI(A)q91(B)wM);incStackPtr();--mStackPtr;q4
+Lig;}
+q4
+d5
+h3:qQ
+hE
+qV
+hI
+B=hQ
+wB(470,aK
+aA
+wH" "
+wS,m5
+wH
+aA,aI(A)q91(B)wM);q4
+Lgh;}
+q4
+dZ;g7
+dZ:;hD
+wB(461,aK
+wH" "
+wS,m5
+wH,aI(A)q91(B)wM);q4
+Lih;}
+}
+q4
+d5
+hI
+hD
+wB(464,aK
+aA" "
+wS,m5
+aA,aI(A)q91(B)wM);q4
+Lgg;}
+q4
+d5
+cRDiv
+hL
+qZ
+qC
+wB(267,"x"
+a9" "
+wS,"[DO_STACKPLUS1] "
+mK
+a9,aI(A)qD1
+wM);incStackPtr();--mStackPtr;q4
+Lii;}
+wB(281,"cRDiv "
+wS,"[DO_STACKPLUS1] A"
+wH
+a9,aI(A)wM);incStackPtr();--mStackPtr;q4
+Lij;g7
+Default4:;B=qK
+qR
+w4
+wB(458,aK" "
+wS,m5,aI(A)q91(B)wM);q4
+Lge;}
+}
+}
+if(gV
+h2
+B=qK
+qO
+B
+qP
+1
+gA
+oM
+C=oC
+qR
+C==A){D=qL
+4]qR
+D==B){wB(477,"D[D==B] C[C==A]"
+wH" B[IsVarOpcode(B)&&mData->mByteCode.size()>1] A[IsUnaryOpcode(A)]"
+wH,"D C cSqr"
+wH,aI(A)q91(B)<<", C"
+wY(C)<<", D"
+wY(D)wM);q4
+Lik;}
+}
+}
+}
+qG
+TailCall_cNEqual:g5
+cNEqual:oL
+hU
+wB(360,m1
+wW,"[x] "
+wW,wN);q4
+Lil
+qU
+cSqr:wB(362,q41
+wL
+wW,"[x] "
+wW,wN);q4
+Lil;}
+}
+m9(116,mA
+wW,"[fp_nequal(y,x)]"
+,q81);q4
+Lim;qG
+TailCall_cNeg:g5
+hI
+qS
+h3
+gM
+wB(123,"x"
+wH
+aA,mI,wN);q4
+Lin;qT
+hI
+wB(61,qC1
+aA,,);q4
+Ldn
+qU
+cSin:g9
+wB(244,"x"
+wH" "
+mP
+aA,mI" "
+mP,wN);q4
+Lio;}
+qT
+oQ
+g9
+wB(245,"x"
+wH" cSinh"
+aA,mI" cSinh"
+,wN);q4
+Lip;}
+qT
+cTan:g9
+wB(246,"x"
+wH" "
+mR
+aA,mI" "
+mR,wN);q4
+Liq;}
+qT
+cTanh:g9
+wB(247,"x"
+wH" cTanh"
+aA,mI" cTanh"
+,wN);q4
+Lja;}
+qT
+hM
+wB(100,"x"
+aA,"[-x]"
+,wN);q4
+Ljb;}
+qH
+TailCall_cNot:g5
+cNot:qS
+cAbs:wB(227,mV
+a0,"cNot"
+,);q4
+Ljc
+qU
+cAbsNot:A=dD
+wB(389,"A[IsLogicalOpcode(A)] "
+aS
+a0,"A"
+,aI(A)wM);q4
+Ldn;}
+if(A!=q6){wB(390,"A[A!=cImmed] "
+aS
+a0,"A cAbsNotNot"
+,aI(A)wM);q4
+Ljd;}
+q4
+o0
+qU
+cAbsNotNot:wB(231,"cAbsNotNot"
+a0,aS,);q4
+Lje
+qU
+w8:wB(220,aE
+a0,wW,);q4
+Ljf
+qU
+o1:wB(218,m2
+a0,aR,);q4
+Ljg
+qU
+dK:wB(219,aG
+a0,mJ,);q4
+Ljh
+qU
+cLess:wB(216,mJ
+a0,aG,);q4
+Lji
+qU
+cLessOrEq:wB(217,aR
+a0,m2,);q4
+Ljj
+qU
+cNEqual:wB(221,wW
+a0,aE,);q4
+Ljk
+oF
+wB(226,qC1
+a0,"cNot"
+,);q4
+Ljc
+qU
+cNot:wB(229,"cNot"
+a0,aJ,);q4
+Lbd
+qU
+dS:wB(230,aJ
+a0,"cNot"
+,);q4
+Ljc
+gY
+wB(107,"x"
+a0,"[fp_not(x)]"
+,wN);q4
+Ljl;g7
+o0:;A=dF
+qR
+qX
+wB(391,wJ"cNot"
+,"A "
+aS,aI(A)wM);q4
+Ljm;qG
+TailCall_cNotNot:g5
+dS
+d4
+dF==cNot){wB(232,"cNot "
+aJ,"cNot"
+,);gJ}
+qH
+TailCall_cOr:g5
+cOr
+hH
+wB(223,mX"cOr"
+,aJ,);q4
+w7
+m9(118,mA"cOr"
+,"[fp_or(x,y)]"
+,q81);q4
+Ljn;h8}
+qH
+TailCall_cPow:g5
+cPow:qY
+if(!h5
+x+x)){oY
+cSqr){wB(22,q41"x[!isEvenInteger(x+x)] cPow"
+,mV" [x+x] cPow"
+,wN);q4
+Ljo;}
+}
+if(isInteger(x
+gQ
+w2
+wB(43,q21
+wT,wX
+mL,wN);q4
+Ljp
+qU
+cExp2:wB(44,"cExp2 "
+wT,wX
+q31,wN);q4
+Ljq
+qU
+cPow
+hL
+qZ
+hP!isInteger(y)){wB(42,"y[!isInteger(y)] "
+q61
+wT,aP,q81);q4
+Lka;}
+}
+wB(45,q61
+wT,wX" cPow"
+,wN);q4
+Lkb;}
+}
+if(h5
+x
+hU
+wB(434,mV" x[isEvenInteger(x)] cPow"
+,"[x] cPow"
+,wN);q4
+Lkc
+qU
+h3
+hL]==cAbs){wB(435,mV
+wH" x[isEvenInteger(x)] cPow"
+,"cMul [x] cPow"
+,wN);q4
+Lkd;h8}
+}
+g8)){wB(83,"x[x==Value_t()] cPow"
+,"[Value_t()]"
+wH" [Value_t(1)]"
+aZ,wN);q4
+Lke;}
+g8
+oO
+wB(332,"x[x==Value_t(0.5)] cPow"
+,q51,wN);q4
+Lkf;}
+g8
+1)/g1
+3)){wB(333,"x[x==Value_t(1)/Value_t(3)] cPow"
+,"cCbrt"
+,wN);q4
+Lkg;}
+g8
+1)/g1-3)){wB(334,"x[x==Value_t(1)/Value_t(-3)] cPow"
+,"cCbrt "
+aU,wN);q4
+Lkh;}
+g8-oO
+wB(335,"x[x==Value_t(-0.5)] cPow"
+,"cRSqrt"
+,wN);q4
+Lki;}
+g8-oG
+wB(336,"x[x==Value_t(-1)] cPow"
+,aU,wN);q4
+Lkj;}
+qQ
+h9
+cPow
+hL
+qZ
+hP
+h5
+y)&&!h5
+x*y)){wB(21,"y[isEvenInteger(y)&&!isEvenInteger(x*y)] "
+q61
+m8,mV" "
+aP,q81);q4
+Lkk;}
+wB(330,aY
+q61
+m8,aP,q81);q4
+Lka;o2
+wB(46,q41
+m8,"[x+x] cPow"
+,wN);q4
+Lkl
+qU
+q6:hP
+y!=oP||x>=oP){wB(165,"y[y!=Value_t(0)||x>=Value_t(0)] "
+m8,"[fp_pow(y,x)]"
+,q81);q4
+Lkm;h8}
+wB(455,m8,"[DO_POWI]"
+,wN)qR
+TryCompilePowi(x))gJ}
+qH
+TailCall_cRDiv:g5
+cRDiv:qS
+cSinCos:wB(503,"cSinCos"
+a9,"cCot"
+,);q4
+Lep
+qU
+cSinhCosh:wB(510,"cSinhCosh"
+a9,"cTanh "
+aU,);q4
+Lkn
+gY
+g8
+oG
+wB(268,wO"cRDiv"
+,aU,wN);q4
+Lkj;h8}
+qH
+TailCall_cRSub:g5
+cRSub
+d4
+q0[0
+h1
+wB(77,"cDup"
+mE,"[Value_t()]"
+wH,);q4
+Lko;}
+qH
+TailCall_cRad:g5
+cRad:qS
+h3
+gM
+wB(211,"x"
+wH" cRad"
+,"[DegreesToRadians(x)]"
+wH,wN);q4
+Lkp;qT
+hM
+wB(134,"x cRad"
+,"[DegreesToRadians(x)]"
+,wN);q4
+Lkq;}
+qH
+TailCall_cSec:g5
+cSec:A=qN
+qQ
+h9
+cCos:hD
+wB(497,aK" "
+aO" "
+wI"cSec"
+,"B "
+aO" "
+aT,aI(A)q91(B)wM);q4
+Lbp;qT
+cSin:hD
+wB(495,aK" "
+mP" "
+wI"cSec"
+,"B cSinCos "
+aU,aI(A)q91(B)wM);q4
+Lla;h8
+qG
+TailCall_cSin:g5
+cSin:qS
+hI
+wB(240,m0
+mP,mP
+aA,);q4
+Llb
+gY
+wB(159,"x "
+mP,"[fp_sin(x)]"
+,wN);q4
+Llc;oH
+qN
+oY
+cCsc
+q11(499,aK" cCsc "
+wI
+mP,"B cCsc "
+aT,aI(A)q91(B)wM);q4
+Lbp;}
+}
+qG
+TailCall_cSinh:g5
+oQ
+qS
+cAcosh:wB(437,"cAcosh cSinh"
+,"[DO_STACKPLUS1] "
+q41"[Value_t(-1)] "
+aQ,);incStackPtr();--mStackPtr;q4
+Lld
+qU
+cAsinh:wB(349,"cAsinh cSinh"
+,,);q4
+Ldn
+oF
+wB(241,m0"cSinh"
+,"cSinh"
+aA,);q4
+Lle
+gY
+wB(160,"x cSinh"
+,"[fp_sinh(x)]"
+,wN);q4
+Llf;}
+qH
+TailCall_cSqr:g5
+cSqr:qS
+cAbs:wB(204,mV" cSqr"
+,"cSqr"
+,);q4
+Llg
+oF
+wB(203,m0"cSqr"
+,"cSqr"
+,);q4
+Llg
+qU
+cSqrt:A=dE
+wB(338,wJ
+q51" cSqr"
+,"A"
+,aI(A)wM);q4
+Ldn;h8}
+qH
+TailCall_cSqrt:g5
+cSqrt:qS
+hS
+d4
+qK
+o3
+A=hE
+w0
+if(oC
+o3
+wB(512,"cSqr"
+a3
+q41
+aQ,"A cHypot"
+,aI(A)wM);q4
+Llh;}
+}
+B
+g4
+gV
+B)){A=oC
+w0
+if(qL
+4]o3
+wB(513,"cSqr"
+a3"B[IsUnaryOpcode(B)] "
+q41
+aQ,"A B cHypot"
+," with"
+a8(B)qE1(A)wM);q4
+Lli;}
+}
+}
+o2
+wB(23,q41
+q51,mV,);q4
+Llj
+gY
+if(x>=oP){wB(161,"x[x>=Value_t(0)] "
+q51,"[fp_sqrt(x)]"
+,wN);q4
+Llk;h8}
+qH
+TailCall_cSub:g5
+cSub
+hH
+wB(76,"cDup"
+aW,"[Value_t()]"
+wH,);q4
+Lko
+oF
+wB(200,qC1
+aW,"cAdd"
+,);q4
+Lll
+gY
+g8)){wB(58,"x[x==Value_t()]"
+aW,,wN);q4
+Lba;}
+m9(106,aY"x"
+aW,"[y-x]"
+,q81);q4
+Llm;}
+wB(51,"x"
+aW,"[-x]"
+aZ,wN);q4
+Lln
+gR
+w0
+oY
+cRSub
+dV
+wB(289,"x"
+mE
+a3"cSub"
+,"A"
+aZ" [x]"
+mE,aI(A)qD1
+wM);q4
+Llo;}
+wB(296,a6
+a3"cSub"
+,"[DO_STACKPLUS1] A"
+aW
+mE,aI(A)wM);incStackPtr();--mStackPtr;q4
+Llp;}
+qG
+TailCall_cTan:g5
+cTan:qS
+cAtan2:wB(354,"cAtan2 "
+mR,"cDiv"
+,);q4
+Lgf
+oF
+wB(242,m0
+mR,mR
+aA,);q4
+Llq
+gY
+wB(163,"x "
+mR,"[fp_tan(x)]"
+,wN);q4
+Lma;oH
+qN
+oY
+cCot
+q11(501,aK" cCot "
+wI
+mR,"B cCot "
+aT,aI(A)q91(B)wM);q4
+Lbp;}
+}
+qG
+TailCall_cTanh:g5
+cTanh:qS
+hI
+wB(243,m0"cTanh"
+,"cTanh"
+aA,);q4
+Lmb
+gY
+wB(164,"x cTanh"
+,"[fp_tanh(x)]"
+,wN);q4
+Lmc;}
+qH
+TailCall_cTrunc:g5
+cTrunc:qS
+hM
+wB(138,"x cTrunc"
+,"[fp_trunc(x)]"
+,wN);q4
+Lmd
+gS
+wB(394,"A[IsAlwaysIntegerOpcode(A)] cTrunc"
+,"A"
+,aI(A)wM);gJ
+qG
+g7
+Default0:;A=w5
+qR
+IsComparisonOpcode(h2
+qY
+hK
+qZ
+mW(364,aY"cAdd"
+wF,"[x-y] A"
+,aI(A)qD1<<","
+a1);q4
+Lme;qT
+cAtan
+d4
+dP<fp_const_pi<dH>()*g1
+oO
+wB(380,"cAtan[fp_abs(x)<fp_const_pi<Value_t>()*Value_t(0.5)]"
+wF,"[fp_tan(x)] A"
+,aI(A)qD1
+wM);q4
+Lmf;qT
+cExp
+d4
+dO
+wB(370,"cExp[x>Value_t(0)]"
+wF,"[fp_log(x)] A"
+,aI(A)qD1
+wM);q4
+Lmg;qT
+cExp2
+d4
+dO
+wB(371,"cExp2[x>Value_t(0)]"
+wF,"[fp_log2(x)] A"
+,aI(A)qD1
+wM);q4
+Lmh;qT
+cLog:g3
+wB(373,wP
+mG
+wF,"B [fp_exp(x)] A"
+,aI(A)qD1
+q91(B)wM);q4
+Lmi;qT
+cLog10:g3
+wB(375,wP
+aL
+wF,"B [fp_pow(Value_t(10),x)] A"
+,aI(A)qD1
+q91(B)wM);q4
+Lmj;qT
+cLog2:g3
+wB(374,wP
+aN
+wF,"B [fp_exp2(x)] A"
+,aI(A)qD1
+q91(B)wM);q4
+Lmk;qT
+h3
+hL
+qZ
+hP
+y>oP){wB(366,"y[y>Value_t(0)]"
+wH
+wF,"[x/y] A"
+,aI(A)qD1<<","
+a1);q4
+Lml;}
+if(y<oP){wB(367,"y[y<Value_t(0)]"
+wH
+wF,"[x/y] {OppositeComparisonOpcode(A)}"
+,aI(A)qD1<<","
+a1);q4
+Lmm;}
+qT
+hI
+wB(365,qC1
+wF,"[-x] {OppositeComparisonOpcode(A)}"
+,aI(A)qD1
+wM);q4
+Lmn
+qU
+cPow
+d4
+x>oP
+gA
+qZ
+hP
+y>oP){wB(368,"y[y>Value_t(0)] cPow[x>Value_t(0)]"
+wF,"[fp_pow(x,Value_t(1)/y)] A"
+,aI(A)qD1<<","
+a1);q4
+Lmo;}
+}
+qT
+oQ
+wB(381,"cSinh"
+wF,"[fp_asinh(x)] A"
+,aI(A)qD1
+wM);q4
+Lmp
+qU
+cSqr
+d4
+dO
+wB(369,"cSqr[x>Value_t(0)]"
+wF,mV" [fp_sqrt(x)] A"
+,aI(A)qD1
+wM);q4
+Lmq;qT
+cTanh
+d4
+dP<m7(382,"cTanh[fp_abs(x)<Value_t(1)]"
+wF,"[fp_atanh(x)] A"
+,aI(A)qD1
+wM);q4
+Lna;h8}
+}
+}
+if(d1
+A
+qP
+0){B=q0[0
+hZ
+wB(475,aK" A[IsVarOpcode(A)&&mData->mByteCode.size()>0]"
+,"B"
+mQ,aI(A)q91(B)wM);q4
+Lnb;}
+}
+if(gV
+h2
+B=dF
+qO
+B
+qP
+1){C=qK
+qR
+C==A){D
+g4
+D==B){wB(476,"D[D==B] C[C==A] B[IsVarOpcode(B)&&mData->mByteCode.size()>1] A[IsUnaryOpcode(A)]"
+,"D C"
+mQ,aI(A)q91(B)<<", C"
+wY(C)<<", D"
+wY(D)wM);q4
+Lnc;}
+}
+}
+}
+C=w5
+qR
+IsCommutativeOrParamSwappableBinaryOpcode(C)){qS
+cSin:A=qK
+w1
+3
+gA]==cCos){B=hQ
+wB(505,aK" "
+aO" A[IsVarOpcode(A)&&mData->mByteCode.size()>3] "
+mP" C[IsCommutativeOrParamSwappableBinaryOpcode(C)]"
+,"B cSinCos {GetParamSwappedBinaryOpcode(C)}"
+," with C"
+wY(C)qE1(A)q91(B)wM);q4
+Lnd;}
+}
+qT
+oQ
+A=qK
+w1
+3
+gA]==cCosh){B=hQ
+wB(506,aK" "
+aM" A[IsVarOpcode(A)&&mData->mByteCode.size()>3] cSinh C[IsCommutativeOrParamSwappableBinaryOpcode(C)]"
+,"B cSinhCosh {GetParamSwappedBinaryOpcode(C)}"
+," with C"
+wY(C)qE1(A)q91(B)wM);q4
+Lne;}
+}
+h8}
+}
+}
+q4
+Laa;Laa:qW
+w5);gJ
+Lab:g6
+Lnf:wE(cAbs);q4
+TailCall_cAbs;Lac:q7=dP;gJ
+Lad:q7=fp_acos
+m6
+Lae:q7=fp_acosh
+m6
+Laf:oZ
+4));gG
+Lng:w5=h3;Lnh:g0
+Lni:wE(cMul);q4
+TailCall_cMul;Lag:hV
+4
+dT
+oZ
+4));Lnj:qW
+q6
+hA
+Lah:q7=x+g1
+1);gG
+Lfa:w5=h3;q4
+Lni;Lai:gU
+cSub;Lnk:wE(cSub);q4
+TailCall_cSub;Laj:hW
+2
+gH
+Lnl:g0
+Lnm:wE(cAdd);q4
+TailCall_cAdd;Lak:hW
+oR
+Lnn:qE
+hS);Lno:w5=cRSub;g0
+wE(cRSub);q4
+TailCall_cRSub;Lal:o9;qL
+2
+gK
+q4
+Lnn;Lam:hW
+2
+gH
+q4
+Lno;Lan:hW
+4
+gH
+Lnp:qE
+hS);Lnq:qE
+B);Loa:w5=cSub;g0
+q4
+Lnk;Lao:o9;oC=q6
+q9
+oR
+q4
+Lnp;Lap:hW
+oR
+q4
+Lnq;Laq:gT
+y+x;Lba:qM
+Ldn:q5
+gJ
+Lbb:q8
+oV
+o7
+x
+q71
+gX
+Lnn;Lbc:mM
+A
+gX
+Lnn;Lbd:gU
+dS;Lob:wE(cNotNot);q4
+TailCall_cNotNot;Lbe:gT
+fp_and(x
+d6
+Lbf:q7=fp_asin
+m6
+Lbg:q7=fp_asinh
+m6
+Lbh:q7=fp_atan
+m6
+Lbi:gT
+fp_atan2(gW
+Lbj:q7=fp_atanh
+m6
+Lbk:q7=fp_cbrt
+m6
+Lbl:q1
+cFloor);Loc:w5=cNeg;g0
+wE(cNeg);q4
+TailCall_cNeg;Lbm:q7=fp_ceil
+m6
+Lbn:g6
+Lod:wE(cCos);q4
+TailCall_cCos;Lbo:q7=fp_cos
+m6
+Lbp:dF=cDup;w5=cInv;Loe:wE(cInv);q4
+TailCall_cInv;Lbq:mM
+cSinCos);gJ
+Lca:g6
+wE(cCosh);q4
+TailCall_cCosh;Lcb:q1
+cSqr
+o7
+g1
+1));Lof:qW
+q6
+oJ
+hS);Log:w5=cSqrt;g0
+wE(cSqrt);q4
+TailCall_cSqrt;Lcc:q7=fp_cosh
+m6
+Lcd:mM
+cSinhCosh);gJ
+Lce:q7=RadiansToDegrees
+m6
+Lcf:q1
+cSec
+hA
+Lcg:q1
+cTan
+hA
+Lch:q1
+cSin
+hA
+Lci:oZ));dF
+dJ
+Loh:qE
+dU
+oZ
+1));Loi:qW
+q6);Loj:w5=hS;q4
+Lnl;Lcj:q1
+cNeg
+oJ
+cExp
+hA
+Lck:q1
+cNeg
+oJ
+cExp2
+hA
+Lcl:g6
+q4
+Lfa;Lcm:q1
+cNeg
+oJ
+cPow
+hA
+Lcn:q1
+cCos
+hA
+Lco:q1
+cCsc
+hA
+Lcp:gU
+cTan;Lok:wE(cTan);q4
+TailCall_cTan;Lcq:gU
+cTanh;Lol:wE(cTanh);q4
+TailCall_cTanh;Lda:q1
+cCot
+hA
+Ldb:o9;dI
+Lom:wE(cDiv);q4
+TailCall_cDiv;Ldc:gT
+y/x;q4
+Lba;Ldd:qF1
+q8
+oR
+Lon:w5=cDeg;g0
+wE(cDeg);q4
+TailCall_cDeg;Lde:qF1
+q8
+oR
+Loo:w5=cRad;g0
+wE(cRad);q4
+TailCall_cRad;Ldf:gT
+y/x;dG
+Lng;Ldg:q7=g1
+1)/x;q4
+Lfa;Ldh:mM
+oI
+Lop:g0
+q4
+Lom;Ldi:q8
+3
+gC
+oI
+qF
+x
+q71);Loq:w5=cRDiv;g0
+wE(cRDiv);q4
+TailCall_cRDiv;Ldj:hV
+3
+gC
+oI
+qE
+B
+gX
+Loq;Ldk:dI
+Lpa:wE(cEqual);q4
+TailCall_cEqual;Ldl:gT
+fp_equal(gW
+Ldm:d7
+cExp
+o7
+fp_exp(x)gX
+Lnj;Ldo:q7=fp_exp
+m6
+Ldp:d7
+cExp2
+o7
+fp_exp2(x)gX
+Lnj;Ldq:q7=fp_exp2
+m6
+Lea:qF
+oW
+g1
+2))q71);Lpb:qE
+h3
+gI
+cExp;g0
+wE(cExp);q4
+TailCall_cExp;Leb:q1
+cCeil
+gX
+Loc;Lec:q7=fp_floor
+m6
+Led:gT
+fp_less(x
+d6
+Lee:qM
+q1
+cNeg);Ljm:qE
+cAbsNot);gJ
+Lef:q7=g1
+0.5)/x;qK=d8
+dS;g0
+q4
+Lob;Leg:gT
+fp_lessOrEq(x
+d6
+Leh:qM
+Ljd:q5
+Lpc:qE
+cAbsNotNot);gJ
+Lei:q7=fp_int
+m6
+Lej:gU
+cSec;wE(cSec);q4
+TailCall_cSec;Lek:gU
+cSin;Lpd:wE(cSin);q4
+TailCall_cSin;Lel:q1
+cNeg
+gI
+cPow;Lpe:g0
+Lpf:wE(cPow);q4
+TailCall_cPow;Lem:gU
+cCos;q4
+Lod;Len:gU
+cCsc;wE(cCsc);q4
+TailCall_cCsc;Leo:q1
+cRSqrt);gJ
+Lep:g6
+Lpg:w5=cCot;wE(cCot);q4
+TailCall_cCot;Leq:q7=g1
+1)/x;gJ
+Lfb:q7=g1
+0.5)/x;qK=d8
+cNot;g0
+Lph:wE(cNot);q4
+TailCall_cNot;Lfc:gT
+fp_less(gW
+Lfd:qM
+Lje:w3
+Ljm;Lfe:gT
+fp_lessOrEq(gW
+Lff:qM
+q1
+cNeg
+gX
+Lpc;Lfg:d7
+cLog
+o7
+oW
+x)o8
+Lfh:q1
+dQ
+qE
+cLog);Lpi:qW
+cDup
+gX
+Loj;Lfi:q7=oW
+x);gJ
+Lfj:qF
+dR
+fp_const_e<dH>()));Lpj:dF
+dJ
+q4
+Lng;Lfk:d7
+cLog10
+o7
+dR
+x)o8
+Lfl:q1
+dQ
+qE
+cLog10
+gX
+Lpi;Lfm:q7=dR
+x);gJ
+Lfn:qF
+o4
+fp_const_e<dH>())gX
+Lpj;Lfo:d7
+cLog2
+o7
+o4
+x)o8
+Lfp:q1
+dQ
+qE
+cLog2
+gX
+Lpi;Lfq:q7=o4
+x);gJ
+Lga:gT
+fp_max(x
+d6
+Lgb:gT
+fp_min(x
+d6
+Lgc:gT
+fp_mod(gW
+Lgd:hV
+oR
+q0-=3;q4
+Lpg;Lge:gU
+cSqr;Lpk:wE(cSqr);q4
+TailCall_cSqr;Lgf:gU
+cDiv;q4
+Lom;Lgg:mM
+cSqr
+gX
+Loc;Lgh:hV
+3
+gC
+cSqr);dM
+Loc;Lgi:q7=x+g1
+1);gG
+w5=cPow;q4
+Lpf;Lgj:gG
+q4
+Lni;Lgk:gT
+x;Lpl:dG
+Lnh;Lgl:qF1
+qM
+Lpm:hV
+4
+gH
+Lpn:o6
+x);Lpo:qW
+q6
+gX
+Lnh;Lgm:qM
+q4
+Lpm;Lgn:q8
+4
+gC
+B
+gX
+Lpn;Lgo:q8
+oR
+q4
+Lpn;Lgp:qK
+dJ
+q4
+Ldn;Lgq:dI
+q4
+Lni;Lha:qM
+Lpp:hV
+oR
+gJ
+Lhb:q7=x+x;q4
+Lgj;Lhc:gT
+x;qL
+4]dJ
+q8
+4
+dT
+o6
+y*x
+q71);dM
+Loj;Lhd:gT
+x;d7
+dU
+qF
+y*x
+o8
+Lhe:q7=RadiansToDegrees(x
+gX
+Lgq;Lhf:qG1
+q8
+4
+gH
+Lpq:qE
+dU
+Lqa:qE
+B
+gI
+cDiv;q4
+Lop;Lhg:o9;oC=q6
+q9
+oR
+q4
+Lpq;Lhh:qG1
+q8
+oR
+q4
+Lqa;Lhi:q8
+4
+gH
+q4
+Lnh;Lhj:q8
+4
+dT
+qF
+x+x
+gX
+Lpo;Lhk:qF1
+qM
+q4
+Lpp;Lhl:qG1
+q4
+Lpl;Lhm:o9;q4
+Lgq;Lhn:qG1
+q8
+oR
+Lqb:dM
+Loq;Lho:o9;qL
+2
+gK
+q4
+Lqb;Lhp:qG1
+dG
+Loq;Lhq:q7=h4
+gX
+Lgq;Lia:gT
+x;qL
+4]dJ
+q8
+4
+dT
+o6
+y*x
+q71);dM
+Loa;Lib:qG1
+q4
+Lba;Lic:qM
+w3
+Loc;Lid:dF=cDup;dW-=1;qM
+Lqc:w5=hS;q4
+Lnm;Lie:qM
+w3
+Lon;Lif:qM
+w3
+Loo;Lig:hV
+oV
+gX
+Lpq;Lih:hV
+2
+gH
+Lqd:qE
+cSqr
+gX
+Lnh;Lii:q8
+oV
+o7
+x
+q71
+gX
+Lqb;Lij:mM
+A
+gX
+Lqb;Lik:hV
+oR
+q4
+Lqd;Lil:dI
+Lqe:wE(cNEqual);q4
+TailCall_cNEqual;Lim:gT
+fp_nequal(gW
+Lin:o9;q4
+Lcl;Lio:o9
+gB
+cSin;g0
+q4
+Lpd;Lip:o9
+gB
+cSinh;g0
+wE(cSinh);q4
+TailCall_cSinh;Liq:o9
+gB
+cTan;g0
+q4
+Lok;Lja:o9
+gB
+cTanh;g0
+q4
+Lol;Ljb:o9;gJ
+Ljc:g6
+q4
+Lph;Ljf:gU
+cNEqual;q4
+Lqe;Ljg:gU
+cLessOrEq;wE(cLessOrEq);q4
+TailCall_cLessOrEq;Ljh:gU
+cLess;wE(cLess);q4
+TailCall_cLess;Lji:gU
+dK;wE(cGreaterOrEq);q4
+TailCall_cGreaterOrEq;Ljj:gU
+o1;wE(cGreater);q4
+TailCall_cGreater;Ljk:gU
+w8;q4
+Lpa;Ljl:q7=fp_not
+m6
+Ljn:gT
+fp_or(x
+d6
+Ljo:d7
+dQ
+qF
+x+x);Lqf:qW
+q6
+gX
+Lpe;Ljp:dL
+Lpb;Ljq:qK=d8
+cExp2;g0
+wE(cExp2);q4
+TailCall_cExp2;Lka:qG1
+dG
+Lpe;Lkb:qK
+dJ
+q1
+h3
+gX
+Lpe;Lkc:dI
+q4
+Lpf;Lkd:q8
+3
+dT
+qF
+x
+gX
+Lqf;Lke:q7=g1
+gX
+Loh;Lkf:qM
+w3
+Log;Lkg:qM
+q5
+w5=cCbrt;g0
+wE(cCbrt);q4
+TailCall_cCbrt;Lkh:qM
+q1
+cCbrt);Lqg:w5=cInv;g0
+q4
+Loe;Lki:qM
+q4
+Leo;Lkj:qM
+w3
+Lqg;Lkk:qF1
+q8
+3
+gC
+dQ
+qF
+y*x
+gX
+Lqf;Lkl:q7=x+x;q4
+Lkc;Lkm:gT
+oX
+gW
+Lkn:q1
+cTanh
+gX
+Lqg;Lko:oZ)gX
+Lpj;Lkp:q7=h4
+gX
+Lcl;Lkq:q7=h4);gJ
+Lla:mM
+cSinCos
+gX
+Lqg;Llb:q1
+cSin
+gX
+Loc;Llc:q7=fp_sin
+m6
+Lld:q1
+cSqr
+o7
+g1-1)gX
+Lof;Lle:q1
+cSinh
+gX
+Loc;Llf:q7=fp_sinh
+m6
+Llg:g6
+q4
+Lpk;Llh:hV
+4
+gC
+A);Lqh:w5=cHypot;g0
+wE(cHypot);q4
+TailCall_cHypot;Lli:hV
+5
+gC
+A
+oJ
+B
+gX
+Lqh;Llj:gU
+cAbs;q4
+Lnf;Llk:q7=fp_sqrt
+m6
+Lll:g6
+q4
+Lqc;Llm:gT
+y-x;q4
+Lba;Lln:o9;q4
+Lqc;Llo:q8
+oV
+oJ
+hS
+o7
+x
+q71
+gX
+Lno;Llp:mM
+A
+oJ
+cSub
+gX
+Lno;Llq:q1
+cTan
+gX
+Loc;Lma:q7=fp_tan
+m6
+Lmb:q1
+cTanh
+gX
+Loc;Lmc:q7=fp_tanh
+m6
+Lmd:q7=fp_trunc
+m6
+Lme:gT
+x-y;Lqi:q8
+2
+gH
+Lqj:qE
+A);gJ
+Lmf:q7=fp_tan(x);Lqk:dL
+Lqj;Lmg:q7=oW
+x
+gX
+Lqk;Lmh:q7=o4
+x
+gX
+Lqk;Lmi:q7=fp_exp(x
+gX
+Lqk;Lmj:q7=oX
+g1
+10),x
+gX
+Lqk;Lmk:q7=fp_exp2(x
+gX
+Lqk;Lml:gT
+x/y;q4
+Lqi;Lmm:gT
+x/y;q8
+2
+gH
+Lql:qE
+OppositeComparisonOpcode(A));gJ
+Lmn:o9;dL
+Lql;Lmo:gT
+oX
+x,g1
+1)/y
+gX
+Lqi;Lmp:q7=fp_asinh(x
+gX
+Lqk;Lmq:d7
+dQ
+qF
+fp_sqrt(x)q71
+gX
+Lqj;Lna:q7=fp_atanh(x
+gX
+Lqk;Lnb:qW
+cDup);gJ
+Lnc:dF=cDup;gJ
+Lnd:hV
+3
+gC
+cSinCos);Lqm:qE
+GetParamSwappedBinaryOpcode(C));gJ
+Lne:hV
+3
+gC
+cSinhCosh
+gX
+Lqm;gJ
+q4
+TailCall_cAcos;q4
+TailCall_cAcosh;q4
+TailCall_cAnd;q4
+TailCall_cAsin;q4
+TailCall_cAsinh;q4
+TailCall_cAtan;q4
+TailCall_cAtan2;q4
+TailCall_cAtanh;q4
+TailCall_cCeil;q4
+TailCall_cFloor;q4
+TailCall_cInt;q4
+TailCall_cLog;q4
+TailCall_cLog10;q4
+TailCall_cLog2;q4
+TailCall_cMax;q4
+TailCall_cMin;q4
+TailCall_cMod;q4
+TailCall_cOr;q4
+TailCall_cRDiv;q4
+TailCall_cRad;q4
+TailCall_cSec;q4
+TailCall_cSin;q4
+TailCall_cSinh;q4
+TailCall_cSqrt;q4
+TailCall_cSub;q4
+TailCall_cTan;q4
+TailCall_cTanh;q4
+TailCall_cTrunc;
+#endif
+#if((FP_COMPLEX_VERSION) && (FP_FLOAT_VERSION))
+dH
+x;dH
+gE
+A;hT
+C;hT
+D;qQ
+w5){TailCall_cAbs:g5
+cAbs:qS
+h0}
+qH
+TailCall_cAcos:g5
+cAcos:qY
+wB(172,"x cAcos"
+,"[fp_acos(x)]"
+,wN);q4
+Lad;}
+qH
+TailCall_cAcosh:g5
+cAcosh:qY
+wB(169,"x cAcosh"
+,"[fp_acosh(x)]"
+,wN);q4
+Lae;}
+qH
+TailCall_cAdd:g5
+hG
+Laf;qT
+h3
+hL]==hS){if(qL
+gZ
+Lag;}
+h8}
+q4
+dX
+qU
+d2
+gF
+h1
+wB(313,"cDup"
+a7
+aZ,"[x+Value_t(1)]"
+wH,wN);q4
+Lah;}
+}
+q4
+dX
+oF
+wB(199,qC1
+aZ,"cSub"
+,);q4
+Lai
+gY
+hK
+qZ
+mW(127,aY"cAdd"
+mD,"[y+x]"
+aZ,q81);q4
+Laj;qT
+cRSub:qQ
+hE
+d3
+3
+qZ
+mW(298,aY"cAdd"
+mE
+mD,mN
+aZ
+mE,q81);q4
+Lak;qT
+hI
+wB(299,m0
+a6
+mD,"[-x]"
+aZ
+mE,wN);q4
+Lal
+qU
+q6:mW(297,aY
+a6
+mD,mN
+mE,q81);q4
+Lam;qT
+oA
+Lan;qT
+hI
+wB(293,m0"B[IsVarOpcode(B)]"
+aW
+mD,"[-x]"
+aZ" B"
+aW,wA","
+a8(B)wM);q4
+Lao
+qU
+q6:mW(291,aY"B[IsVarOpcode(B)]"
+aW
+mD,mN" B"
+aW,wA","
+a8(B)<<","
+a1);q4
+Lap;}
+w9
+mW(105,aY
+aF,"[y+x]"
+,q81);q4
+Laq;}
+g8)){wB(57,"x[x==Value_t()]"
+aZ,,wN);q4
+Lba;h8
+g7
+dX:;A=dF
+w0
+oY
+cRSub
+dV
+wB(290,"x"
+mE
+a3"cAdd"
+,"[DO_STACKPLUS1] A [x]"
+aZ
+mE,aI(A)qD1
+wM);incStackPtr();--mStackPtr;q4
+Lbb;}
+wB(295,a6
+a3"cAdd"
+,"[DO_STACKPLUS1] A"
+aZ
+mE,aI(A)wM);incStackPtr();--mStackPtr;q4
+Lbc;}
+qG
+TailCall_cAnd:g5
+cAnd
+hH
+wB(224,mX"cAnd"
+,aJ,);q4
+w7
+m9(117,mA"cAnd"
+,"[fp_and(x,y)]"
+,q81);q4
+Lbe;h8}
+qH
+TailCall_cArg:g5
+cArg:qY
+wB(190,"x cArg"
+,"[fp_arg(x)]"
+,wN);q4
+Lbf;}
+qH
+TailCall_cAsin:g5
+cAsin:qY
+wB(173,"x cAsin"
+,"[fp_asin(x)]"
+,wN);q4
+Lbg;}
+qH
+TailCall_cAsinh:g5
+cAsinh:qY
+wB(170,"x cAsinh"
+,"[fp_asinh(x)]"
+,wN);q4
+Lbh;}
+qH
+TailCall_cAtan:g5
+cAtan:qY
+if(g1
+x.real(),fp_abs(x.imag()))!=g1
+0,oG
+wB(174,"x[Value_t(x.real(),fp_abs(x.imag()))!=Value_t(0,1)] cAtan"
+,"[fp_atan(x)]"
+,wN);q4
+Lbi;qG
+TailCall_cAtan2:g5
+cAtan2:qY
+m9(139,mA"cAtan2"
+,"[fp_atan2(y,x)]"
+,q81);q4
+Lbj;qG
+TailCall_cAtanh:g5
+cAtanh:qY
+if(g1
+fp_abs(x.real()),x.imag())!=g1
+1,0)){wB(171,"x[Value_t(fp_abs(x.real()),x.imag())!=Value_t(1,0)] cAtanh"
+,"[fp_atanh(x)]"
+,wN);q4
+Lbk;qG
+TailCall_cCbrt:g5
+cCbrt:qY
+wB(175,"x cCbrt"
+,"[fp_cbrt(x)]"
+,wN);q4
+Lbl;}
+qH
+TailCall_cCeil:g5
+cCeil:qS
+hI
+wB(402,m0
+q01,mS
+aA,);q4
+Lbm
+gY
+wB(135,"x "
+q01,"[fp_ceil(x)]"
+,wN);q4
+Lbn
+gS
+wB(396,"A[IsAlwaysIntegerOpcode(A)] "
+q01,"A"
+,aI(A)wM);gJ
+qG
+TailCall_cConj:g5
+cConj:qS
+cConj:wB(63,mY" "
+mY,,);oS
+gY
+wB(193,"x "
+mY,"[fp_conj(x)]"
+,wN);q4
+Lbp;}
+qH
+TailCall_cCos:g5
+cCos:qS
+cAcos:wB(346,"cAcos "
+aO,,);q4
+oE
+wB(238,m0
+aO,aO,);q4
+Lbq
+gY
+wB(176,"x "
+aO,"[fp_cos(x)]"
+,wN);q4
+Lca;oH
+qN
+qQ
+h9
+cSec:hD
+wB(500,aK" cSec "
+wI
+aO,"B cSec "
+aT,aI(A)q91(B)wM);q4
+Lcb;qT
+cSin:hD
+wB(494,aK" "
+mP" "
+wI
+aO,"B cSinCos"
+,aI(A)q91(B)wM);q4
+Lcc;h8}
+qG
+TailCall_cCosh:g5
+cCosh:qS
+cAsinh:wB(450,"cAsinh "
+aM,"[DO_STACKPLUS1] "
+q41"[Value_t(1)] "
+aQ,);incStackPtr();--mStackPtr;q4
+Lcd
+oF
+wB(239,m0
+aM,aM,);q4
+Lce
+gY
+wB(177,"x "
+aM,"[fp_cosh(x)]"
+,wN);q4
+Lcf;oH
+qN
+oY
+cSinh
+q11(507,aK" cSinh "
+wI
+aM,"B cSinhCosh"
+,aI(A)q91(B)wM);q4
+Lcg;}
+}
+qG
+TailCall_cCot:g5
+cCot:A=qN
+oY
+cTan
+q11(498,aK" "
+mR" "
+wI"cCot"
+,"B "
+mR" "
+aT,aI(A)q91(B)wM);q4
+Lcb;}
+qG
+TailCall_cCsc:g5
+cCsc:A=qN
+oY
+cSin
+q11(496,aK" "
+mP" "
+wI"cCsc"
+,"B "
+mP" "
+aT,aI(A)q91(B)wM);q4
+Lcb;}
+qG
+TailCall_cDeg:g5
+cDeg:qY
+wB(133,"x cDeg"
+,"[RadiansToDegrees(x)]"
+,wN);q4
+Lch;}
+qH
+TailCall_cDiv:g5
+cDiv:qS
+cCos:wB(250,aO
+mF,"cSec"
+wH,);q4
+Lci
+qU
+cCot:wB(254,"cCot"
+mF,mR
+wH,);q4
+Lcj
+qU
+cCsc:wB(252,"cCsc"
+mF,mP
+wH,);q4
+Lck
+qU
+cDup:wB(78,"cDup"
+mF,"[Value_t()]"
+wH" [Value_t(1)]"
+aZ,);q4
+Lcl
+qU
+w2
+wB(408,"cExp"
+mF,m0"cExp"
+wH,);q4
+Lcm
+qU
+cExp2:wB(409,"cExp2"
+mF,m0"cExp2"
+wH,);q4
+Lcn
+qU
+cInv:wB(213,aU
+mF,"cMul"
+,);q4
+Lco
+qU
+cPow:wB(407,"cPow"
+mF,m0"cPow"
+wH,);q4
+Lcp
+qU
+cSec:wB(253,"cSec"
+mF,aO
+wH,);q4
+Lcq
+qU
+cSin:wB(249,mP
+mF,"cCsc"
+wH,);q4
+Lda
+qU
+cSinCos:wB(502,"cSinCos"
+mF,mR,);q4
+Ldb
+qU
+cSinhCosh:wB(509,"cSinhCosh"
+mF,"cTanh"
+,);q4
+Ldc
+qU
+cTan:wB(251,mR
+mF,"cCot"
+wH,);q4
+Ldd
+gY
+if
+hF
+gQ
+hI
+wB(125,m0
+a4"cDiv"
+,"[-x]"
+mF,wN);q4
+Lde
+qU
+q6:mW(103,aY
+a4"cDiv"
+,"[y/x]"
+,q81);q4
+Ldf;}
+}
+g8
+oG
+wB(56,wO"cDiv"
+,,wN);q4
+Lba;}
+dB
+h3
+gA
+qZ
+hP(y/x)==fp_const_rad_to_deg
+h7
+wB(321,"y[(y/x)==fp_const_rad_to_deg<Value_t>()]"
+wH" "
+wR,"cDeg"
+,q81);q4
+Ldg;}
+if((y/x)==fp_const_deg_to_rad
+h7
+wB(322,"y[(y/x)==fp_const_deg_to_rad<Value_t>()]"
+wH" "
+wR,"cRad"
+,q81);q4
+Ldh;}
+wB(323,"y"
+wH" "
+wR,"[y/x]"
+wH,q81);q4
+Ldi;}
+}
+wB(325,wR,"[Value_t(1)/x]"
+wH,wN);q4
+Ldj;}
+gP
+cDiv:hC
+wB(271,aX"cDiv "
+wV,"[DO_STACKPLUS1] B A"
+wH
+mF,aI(A)q91(B)wM);incStackPtr();--mStackPtr;q4
+Ldk;qT
+cRDiv:qQ
+hE
+qV
+hM
+wB(266,"x"
+a9" "
+wV,"A"
+wH" [x]"
+a9,aI(A)qD1
+wM);q4
+Ldl;g7
+hC
+wB(265,"B[IsVarOpcode(B)]"
+a9" "
+wV,"A"
+wH" B"
+a9,aI(A)q91(B)wM);q4
+Ldm;}
+h8}
+qG
+TailCall_cEqual:g5
+w8:oL
+hU
+wB(359,m1
+aE,"[x] "
+aE,wN);q4
+Ldn
+qU
+cSqr:wB(361,q41
+wL
+aE,"[x] "
+aE,wN);q4
+Ldn;}
+}
+m9(115,mA
+aE,"[fp_equal(y,x)]"
+,q81);q4
+Ldo;qG
+TailCall_cExp:g5
+w2
+qS
+hS
+gM
+wB(404,aF
+mL,q21"[fp_exp(x)]"
+wH,wN);q4
+Ldp;qT
+cLog:A=dE
+wB(340,wJ
+mG
+mL,"A"
+,aI(A)wM);oS;qT
+hM
+wB(178,"x"
+mL,"[fp_exp(x)]"
+,wN);q4
+Ldq;}
+qH
+TailCall_cExp2:g5
+cExp2:qS
+hS
+gM
+wB(405,aF
+q31,"cExp2 [fp_exp2(x)]"
+wH,wN);q4
+Lea;qT
+cLog2:A=dE
+wB(341,wJ
+aN
+q31,"A"
+,aI(A)wM);oS;qT
+hM
+wB(179,"x"
+q31,"[fp_exp2(x)]"
+,wN);q4
+Leb;}
+wB(479,"cExp2"
+,"[DO_STACKPLUS1] [fp_log(Value_t(2))]"
+wH
+mL,);incStackPtr();--mStackPtr;q4
+Lec;TailCall_cFloor:g5
+cFloor:qS
+hI
+wB(401,m0
+mS,q01
+aA,);q4
+Led
+gY
+wB(136,"x "
+mS,"[fp_floor(x)]"
+,wN);q4
+Lee
+gS
+wB(395,"A[IsAlwaysIntegerOpcode(A)] "
+mS,"A"
+,aI(A)wM);gJ
+qG
+TailCall_cGreater:g5
+o1:qY
+m9(113,mA
+m2,"[fp_less(x,y)]"
+,q81);q4
+Lef;qG
+TailCall_cGreaterOrEq:g5
+dK:qY
+m9(114,mA
+aG,"[fp_lessOrEq(x,y)]"
+,q81);q4
+Leg;qG
+TailCall_cHypot:g5
+cHypot
+d4
+dF==cSinCos){wB(84,"cSinCos cHypot"
+,"[Value_t()]"
+wH" [Value_t(1)]"
+aZ,);q4
+Lcl;}
+qH
+TailCall_cImag:g5
+cImag:qS
+cAbs:wB(81,mV" "
+mZ,"[Value_t()]"
+wH,);q4
+Leh
+qU
+cReal:wB(80,"cReal "
+mZ,"[Value_t()]"
+wH,);q4
+Leh
+gY
+wB(192,"x "
+mZ,"[fp_imag(x)]"
+,wN);q4
+Lei;}
+qH
+TailCall_cInt:g5
+cInt:qS
+hM
+wB(137,"x cInt"
+,"[fp_int(x)]"
+,wN);q4
+Lej
+gS
+wB(397,"A[IsAlwaysIntegerOpcode(A)] cInt"
+,"A"
+,aI(A)wM);gJ
+qG
+TailCall_cInv:g5
+cInv:qS
+cCos:wB(256,aO" "
+aU,"cSec"
+,);q4
+Lek
+qU
+cCot:wB(260,"cCot "
+aU,mR,);q4
+Ldb
+qU
+cCsc:wB(258,"cCsc "
+aU,mP,);q4
+Lel
+qU
+cInv:wB(62,aU" "
+aU,,);oS
+qU
+cPow:wB(355,q61
+aU,m0"cPow"
+,);q4
+Lem
+qU
+cSec:wB(259,"cSec "
+aU,aO,);q4
+Len
+qU
+cSin:wB(255,mP" "
+aU,"cCsc"
+,);q4
+Leo
+qU
+cSqrt:wB(206,q51" "
+aU,"cRSqrt"
+,);q4
+Lep
+qU
+cTan:wB(257,mR" "
+aU,"cCot"
+,);q4
+Leq
+gY
+if
+hF)){wB(101,a4
+aU,"[Value_t(1)/x]"
+,wN);q4
+Lfa;h8}
+qH
+TailCall_cLess:g5
+cLess:oL)){A=dE
+wB(301,wJ
+wL
+mJ,mK,qB1(A)wM);q4
+Lfb;}
+}
+m9(111,mA
+mJ,"[fp_less(y,x)]"
+,q81);q4
+Lfc;qG
+TailCall_cLessOrEq:g5
+cLessOrEq:qY
+m9(112,mA
+aR,"[fp_lessOrEq(y,x)]"
+,q81);q4
+Lfd;qG
+TailCall_cLog:g5
+cLog:mT(343,q21
+mG,,);oS
+qU
+gL
+wB(491,mU
+mG,mG" [fp_log(x)]"
+aZ,wN);q4
+Lfe;}
+oD
+wB(180,qA1
+mG,"[fp_log(x)]"
+,wN);q4
+Lff;h8}
+qH
+TailCall_cLog10:g5
+cLog10:mT(481,q21
+aL,"[DO_STACKPLUS1] [fp_log10(fp_const_e<Value_t>())]"
+wH,);incStackPtr();--mStackPtr;q4
+Lfg
+qU
+gL
+wB(492,mU
+aL,aL" [fp_log10(x)]"
+aZ,wN);q4
+Lfh;}
+oD
+wB(181,qA1
+aL,"[fp_log10(x)]"
+,wN);q4
+Lfi;h8}
+qH
+TailCall_cLog2:g5
+cLog2:mT(480,q21
+aN,"[DO_STACKPLUS1] [fp_log2(fp_const_e<Value_t>())]"
+wH,);incStackPtr();--mStackPtr;q4
+Lfj
+qU
+cExp2:wB(344,"cExp2 "
+aN,,);oS
+qU
+gL
+wB(490,mU
+aN,aN" [fp_log2(x)]"
+aZ,wN);q4
+Lfk;}
+oD
+wB(182,qA1
+aN,"[fp_log2(x)]"
+,wN);q4
+Lfl;h8}
+qH
+TailCall_cMax:g5
+cMax
+hH
+wB(60,mX
+mB,,);oS
+gY
+m9(141,mA
+mB,"[fp_max(x,y)]"
+,q81);q4
+Lfm;}
+gP
+cDup:hD
+wB(66,aK
+mQ
+a3
+mB,"B"
+mQ,aI(A)q91(B)wM);oS;qT
+cMax:hD
+wB(68,aK" "
+mB
+a3
+mB,"B "
+mB,aI(A)q91(B)wM);oS;h8}
+qG
+TailCall_cMin:g5
+cMin
+hH
+wB(59,mX
+mC,,);oS
+gY
+m9(140,mA
+mC,"[fp_min(x,y)]"
+,q81);q4
+Lfn;}
+gP
+cDup:hD
+wB(65,aK
+mQ
+a3
+mC,"B"
+mQ,aI(A)q91(B)wM);oS;qT
+cMin:hD
+wB(67,aK" "
+mC
+a3
+mC,"B "
+mC,aI(A)q91(B)wM);oS;h8}
+qG
+TailCall_cMod:g5
+cMod:qY
+if
+hF)){m9(104,aY
+a4"cMod"
+,"[fp_mod(y,x)]"
+,q81);q4
+Lfo;}
+qG
+TailCall_cMul:g5
+h3:qS
+cCsc:A=qK
+w1
+3
+gA]==cCos){B=hQ
+wB(508,aK" "
+aO" A[IsVarOpcode(A)&&mData->mByteCode.size()>3] cCsc"
+wH,"B cCot"
+,aI(A)q91(B)wM);q4
+Lfp;}
+}
+}
+q4
+dY
+qU
+cDup:wB(202,"cDup"
+wH,"cSqr"
+,);q4
+Lfq
+qU
+cInv:wB(214,aU
+wH,"cDiv"
+,);q4
+Lga
+oF
+qQ
+h9
+cDup:wB(467,"cDup"
+aA
+wH,"cSqr"
+aA,);q4
+Lgb;oH
+qK
+qO
+A)gA
+oM
+B=hQ
+wB(473,aK
+wH
+a3
+qC1
+wH,m5
+wH
+aA,aI(A)q91(B)wM);q4
+Lgc;}
+}
+}
+}
+q4
+dY
+qU
+cPow
+gM
+if
+gF
+h1
+wB(314,mX
+m8
+wH,"[x+Value_t(1)] cPow"
+,wN);q4
+Lgd;}
+}
+q4
+dY
+gY
+g8
+gQ
+h3:A=hE
+w0
+wB(93,wS" "
+wZ,wX,qB1(A)wM);q4
+Lge;}
+q4
+Default3;g7
+Default3:;A=qK
+qR
+IsBinaryOpcode(A)g2
+h2
+qQ
+hE
+qV
+q6:mW(92,aY
+wD,wX,qB1(A)<<","
+a1);q4
+Lgf;g7
+B
+g4
+IsBinaryOpcode(B)g2
+B)){qQ
+oC
+qV
+q6:mW(96,aY
+wK,mK,qB1(A)q91(B)<<","
+a1);q4
+Lgg;g7
+C=oC
+qO
+C)){wB(94,"C[IsVarOpcode(C)] "
+wK,mK,qB1(A)q91(B)<<", C"
+wY(C)wM);q4
+Lgh;}
+if(gV
+C)g2
+C)){wB(95,"C[IsUnaryOpcode(C)&&!HasInvalidRangesOpcode(C)] "
+wK,"B "
+mK,qB1(A)q91(B)<<", C"
+wY(C)wM);q4
+Lgi;}
+}
+}
+if(d1
+B)){wB(90,aX
+wD,wX,qB1(A)q91(B)wM);q4
+Lge;}
+if(gV
+B)g2
+B)){wB(91,"B[IsUnaryOpcode(B)&&!HasInvalidRangesOpcode(B)] "
+wD,mK,qB1(A)q91(B)wM);q4
+Lgj;}
+}
+}
+if(d1
+h2
+wB(88,a5" "
+wZ,"[x]"
+,qB1(A)wM);q4
+Lgk;}
+if(gV
+A)g2
+h2
+wB(89,"A[IsUnaryOpcode(A)&&!HasInvalidRangesOpcode(A)] "
+wZ,wX,qB1(A)wM);q4
+Lgl;}
+}
+}
+qQ
+h9
+hS:qQ
+hE
+qV
+cDup
+d4
+x+oU
+wB(316,"cDup[x+x==Value_t(1)]"
+aZ
+a7,,wN);q4
+Lgm;}
+wB(317,aH
+a7,"[x+x]"
+wH,wN);q4
+Lgn
+qU
+o5
+3
+qZ
+hO
+A=qL
+4]w0
+wB(386,a5" y"
+wH
+aZ
+a7,wX" A "
+m3
+aZ,wA", "
+aY"= "
+<<y
+qE1(A)wM);q4
+Lgo;}
+w9
+mW(385,aY"cAdd"
+a7,wX" [y*x]"
+aZ,q81);q4
+Lgp;qT
+cDeg:wB(209,"cDeg"
+a7,"[RadiansToDegrees(x)]"
+wH,wN);q4
+Lgq
+qU
+cDiv
+oB
+qV
+o5
+4
+qZ
+mW(278,"y"
+wH" "
+aX
+mH,m3
+qH1,wA","
+a8(B)<<","
+a1);q4
+Lha;qT
+hI
+wB(279,m0
+aX
+mH,mI
+qH1,wA","
+a8(B)wM);q4
+Lhb
+qU
+q6:mW(277,aY
+aX
+mH,"[y*x] B"
+mF,wA","
+a8(B)<<","
+a1);q4
+Lhc;}
+qT
+h3:qQ
+hE
+d3
+3
+h1
+if(x+oU
+wB(318,"cDup[x+x==Value_t(1)]"
+aZ
+wH
+a7,"cMul"
+,wN);q4
+Lhd;}
+wB(319,aH
+wH
+a7,"cMul [x+x]"
+wH,wN);q4
+Lhe;w9
+hP
+y*oU
+wB(70,"y[y*x==Value_t(1)]"
+wH
+a7,,q81);q4
+Lhf;}
+if((y*x)==fp_const_rad_to_deg
+h7
+wB(307,"y[(y*x)==fp_const_rad_to_deg<Value_t>()]"
+wH
+a7,"cDeg"
+,q81);q4
+Ldg;}
+if((y*x)==fp_const_deg_to_rad
+h7
+wB(308,"y[(y*x)==fp_const_deg_to_rad<Value_t>()]"
+wH
+a7,"cRad"
+,q81);q4
+Ldh;}
+wB(128,"y"
+wH
+a7,m3,q81);q4
+Lhg;qT
+hI
+wB(122,qC1
+a7,mI,wN);q4
+Lhh
+qU
+cRDiv:qQ
+hE
+qV
+o5
+3
+qZ
+mW(285,"y"
+wH
+a9
+a7,m3
+a9,q81);q4
+Lhi;qT
+hI
+wB(286,qC1
+a9
+a7,mI
+a9,wN);q4
+Lhj
+qU
+q6:mW(284,"y"
+a9
+a7,"[y*x]"
+a9,q81);q4
+Lhk;qT
+cRad:wB(210,"cRad"
+a7,"[DegreesToRadians(x)]"
+wH,wN);q4
+Lhl
+qU
+cSub
+hL
+oM
+if(qL
+3
+qZ
+hO
+A=qL
+4]w0
+wB(387,a5" y"
+wH
+aW
+a7,wX" A "
+m3
+aW,wA", "
+aY"= "
+<<y
+qE1(A)wM);q4
+Lhm;}
+}
+w9
+mW(102,"y"
+a7,"[y*x]"
+,q81);q4
+Lhn;}
+g8
+oG
+wB(55,"x[x==Value_t(1)]"
+wH,,wN);q4
+Lba;}
+g8-oG
+wB(124,"x[x==Value_t(-1)]"
+wH,qC1,wN);q4
+Lho;}
+g8
+2)){wB(198,"x[x==Value_t(2)]"
+wH,aH,wN);q4
+Lhp;}
+if(x==fp_const_rad_to_deg
+h7
+wB(207,"x[x==fp_const_rad_to_deg<Value_t>()]"
+wH,"cDeg"
+,wN);q4
+Lhq;}
+if(x==fp_const_deg_to_rad
+h7
+wB(208,"x[x==fp_const_deg_to_rad<Value_t>()]"
+wH,"cRad"
+,wN);q4
+Lia;h8
+g7
+dY:;A=dF
+qO
+A
+gQ
+cDiv:hC
+wB(274,aX"cDiv "
+wS,"[DO_STACKPLUS1] A"
+wH
+qH1,aI(A)q91(B)wM);incStackPtr();--mStackPtr;q4
+Lib;}
+q4
+d5
+h3:qQ
+hE
+qV
+hI
+B=hQ
+wB(470,aK
+aA
+wH" "
+wS,m5
+wH
+aA,aI(A)q91(B)wM);q4
+Lgc;}
+q4
+dZ;g7
+dZ:;hD
+wB(461,aK
+wH" "
+wS,m5
+wH,aI(A)q91(B)wM);q4
+Lic;}
+}
+q4
+d5
+hI
+hD
+wB(464,aK
+aA" "
+wS,m5
+aA,aI(A)q91(B)wM);q4
+Lgb;}
+q4
+d5
+cRDiv
+hL
+qZ
+qC
+wB(267,"x"
+a9" "
+wS,"[DO_STACKPLUS1] "
+mK
+a9,aI(A)qD1
+wM);incStackPtr();--mStackPtr;q4
+Lid;}
+wB(281,"cRDiv "
+wS,"[DO_STACKPLUS1] A"
+wH
+a9,aI(A)wM);incStackPtr();--mStackPtr;q4
+Lie;g7
+Default4:;B=qK
+qR
+w4
+wB(458,aK" "
+wS,m5,aI(A)q91(B)wM);q4
+Lfq;}
+}
+}
+if(gV
+h2
+B=qK
+qO
+B
+qP
+1
+gA
+oM
+C=oC
+qR
+C==A){D=qL
+4]qR
+D==B){wB(477,"D[D==B] C[C==A]"
+wH" B[IsVarOpcode(B)&&mData->mByteCode.size()>1] A[IsUnaryOpcode(A)]"
+wH,"D C cSqr"
+wH,aI(A)q91(B)<<", C"
+wY(C)<<", D"
+wY(D)wM);q4
+Lif;}
+}
+}
+}
+qG
+TailCall_cNEqual:g5
+cNEqual:oL
+hU
+wB(360,m1
+wW,"[x] "
+wW,wN);q4
+Lig
+qU
+cSqr:wB(362,q41
+wL
+wW,"[x] "
+wW,wN);q4
+Lig;}
+}
+m9(116,mA
+wW,"[fp_nequal(y,x)]"
+,q81);q4
+Lih;qG
+TailCall_cNeg:g5
+hI
+qS
+h3
+gM
+wB(123,"x"
+wH
+aA,mI,wN);q4
+Lii;qT
+hI
+wB(61,qC1
+aA,,);oS
+qU
+cSin:g9
+wB(244,"x"
+wH" "
+mP
+aA,mI" "
+mP,wN);q4
+Lij;}
+qT
+oQ
+g9
+wB(245,"x"
+wH" cSinh"
+aA,mI" cSinh"
+,wN);q4
+Lik;}
+qT
+cTan:g9
+wB(246,"x"
+wH" "
+mR
+aA,mI" "
+mR,wN);q4
+Lil;}
+qT
+cTanh:g9
+wB(247,"x"
+wH" cTanh"
+aA,mI" cTanh"
+,wN);q4
+Lim;}
+qT
+hM
+wB(100,"x"
+aA,"[-x]"
+,wN);q4
+Lin;}
+qH
+TailCall_cNot:g5
+cNot:qS
+cAbsNotNot:wB(231,"cAbsNotNot"
+a0,aS,);q4
+Lio
+qU
+w8:wB(220,aE
+a0,wW,);q4
+Lip
+qU
+o1:wB(218,m2
+a0,aR,);q4
+Liq
+qU
+dK:wB(219,aG
+a0,mJ,);q4
+Lja
+qU
+cLess:wB(216,mJ
+a0,aG,);q4
+Ljb
+qU
+cLessOrEq:wB(217,aR
+a0,m2,);q4
+Ljc
+qU
+cNEqual:wB(221,wW
+a0,aE,);q4
+Ljd
+qU
+cNot:wB(229,"cNot"
+a0,aJ,);q4
+Lbd
+qU
+dS:wB(230,aJ
+a0,"cNot"
+,);q4
+Lje
+gY
+wB(107,"x"
+a0,"[fp_not(x)]"
+,wN);q4
+Ljf;}
+qH
+TailCall_cNotNot:g5
+dS
+d4
+dF==cNot){wB(232,"cNot "
+aJ,"cNot"
+,);gJ}
+qH
+TailCall_cOr:g5
+cOr
+hH
+wB(223,mX"cOr"
+,aJ,);q4
+w7
+m9(118,mA"cOr"
+,"[fp_or(x,y)]"
+,q81);q4
+Ljg;h8}
+qH
+TailCall_cPolar:g5
+cPolar
+d4
+q0[0
+qZ
+y=q7;qJ
+x
+gO
+wB(194,"x "
+aY"cPolar"
+,"[fp_polar(x,y)]"
+," with "
+aY"= "
+<<y
+qD1
+wM);q4
+Ljh;qG
+TailCall_cPow:g5
+cPow:qY
+if(isInteger(x
+gQ
+w2
+wB(43,q21
+wT,wX
+mL,wN);q4
+Lji
+qU
+cExp2:wB(44,"cExp2 "
+wT,wX
+q31,wN);q4
+Ljj
+qU
+cPow
+hL
+qZ
+hP!isInteger(y)){wB(42,"y[!isInteger(y)] "
+q61
+wT,aP,q81);q4
+Ljk;}
+}
+wB(45,q61
+wT,wX" cPow"
+,wN);q4
+Ljl;}
+}
+g8)){wB(83,"x[x==Value_t()] cPow"
+,"[Value_t()]"
+wH" [Value_t(1)]"
+aZ,wN);q4
+Ljm;}
+g8
+oO
+wB(332,"x[x==Value_t(0.5)] cPow"
+,q51,wN);q4
+Ljn;}
+g8
+1)/g1
+3)){wB(333,"x[x==Value_t(1)/Value_t(3)] cPow"
+,"cCbrt"
+,wN);q4
+Ljo;}
+g8
+1)/g1-3)){wB(334,"x[x==Value_t(1)/Value_t(-3)] cPow"
+,"cCbrt "
+aU,wN);q4
+Ljp;}
+g8-oO
+wB(335,"x[x==Value_t(-0.5)] cPow"
+,"cRSqrt"
+,wN);q4
+Ljq;}
+g8-oG
+wB(336,"x[x==Value_t(-1)] cPow"
+,aU,wN);q4
+Lka;}
+qQ
+h9
+cPow
+hL
+qZ
+mW(330,aY
+q61
+m8,aP,q81);q4
+Ljk;o2
+wB(46,q41
+m8,"[x+x] cPow"
+,wN);q4
+Lkb
+qU
+q6:mW(189,aY
+m8,"[fp_pow(y,x)]"
+,q81);q4
+Lkc;}
+wB(455,m8,"[DO_POWI]"
+,wN)qR
+TryCompilePowi(x))gJ}
+qH
+TailCall_cRDiv:g5
+cRDiv:qS
+cSinCos:wB(503,"cSinCos"
+a9,"cCot"
+,);q4
+Leq
+qU
+cSinhCosh:wB(510,"cSinhCosh"
+a9,"cTanh "
+aU,);q4
+Lkd
+gY
+g8
+oG
+wB(268,wO"cRDiv"
+,aU,wN);q4
+Lka;h8}
+qH
+TailCall_cRSub:g5
+cRSub
+d4
+q0[0
+h1
+wB(77,"cDup"
+mE,"[Value_t()]"
+wH,);q4
+Leh;}
+qH
+TailCall_cRad:g5
+cRad:qS
+h3
+gM
+wB(211,"x"
+wH" cRad"
+,"[DegreesToRadians(x)]"
+wH,wN);q4
+Lke;qT
+hM
+wB(134,"x cRad"
+,"[DegreesToRadians(x)]"
+,wN);q4
+Lkf;}
+qH
+TailCall_cReal:g5
+cReal:qY
+wB(191,"x cReal"
+,"[fp_real(x)]"
+,wN);q4
+Lkg;}
+qH
+TailCall_cSec:g5
+cSec:A=qN
+qQ
+h9
+cCos:hD
+wB(497,aK" "
+aO" "
+wI"cSec"
+,"B "
+aO" "
+aT,aI(A)q91(B)wM);q4
+Lcb;qT
+cSin:hD
+wB(495,aK" "
+mP" "
+wI"cSec"
+,"B cSinCos "
+aU,aI(A)q91(B)wM);q4
+Lkh;h8
+qG
+TailCall_cSin:g5
+cSin:qS
+cAsin:wB(345,"cAsin "
+mP,,);q4
+oE
+wB(240,m0
+mP,mP
+aA,);q4
+Lki
+gY
+wB(183,"x "
+mP,"[fp_sin(x)]"
+,wN);q4
+Lkj;oH
+qN
+oY
+cCsc
+q11(499,aK" cCsc "
+wI
+mP,"B cCsc "
+aT,aI(A)q91(B)wM);q4
+Lcb;}
+}
+qG
+TailCall_cSinh:g5
+oQ
+qS
+cAcosh:wB(437,"cAcosh cSinh"
+,"[DO_STACKPLUS1] "
+q41"[Value_t(-1)] "
+aQ,);incStackPtr();--mStackPtr;q4
+Lkk
+qU
+cAsinh:wB(349,"cAsinh cSinh"
+,,);q4
+oE
+wB(241,m0"cSinh"
+,"cSinh"
+aA,);q4
+Lkl
+gY
+wB(184,"x cSinh"
+,"[fp_sinh(x)]"
+,wN);q4
+Lkm;}
+qH
+TailCall_cSqr:g5
+cSqr:qS
+cAbs:wB(204,mV" cSqr"
+,"cSqr"
+,);q4
+Lkn
+oF
+wB(203,m0"cSqr"
+,"cSqr"
+,);q4
+Lkn
+qU
+cSqrt:A=dE
+wB(338,wJ
+q51" cSqr"
+,"A"
+,aI(A)wM);oS;h8}
+qH
+TailCall_cSqrt:g5
+cSqrt:qS
+hS
+d4
+qK
+o3
+A=hE
+w0
+if(oC
+o3
+wB(512,"cSqr"
+a3
+q41
+aQ,"A cHypot"
+,aI(A)wM);q4
+Lko;}
+}
+B
+g4
+gV
+B)){A=oC
+w0
+if(qL
+4]o3
+wB(513,"cSqr"
+a3"B[IsUnaryOpcode(B)] "
+q41
+aQ,"A B cHypot"
+," with"
+a8(B)qE1(A)wM);q4
+Lkp;}
+}
+}
+o2
+wB(23,q41
+q51,mV,);q4
+Lkq
+gY
+wB(185,"x "
+q51,"[fp_sqrt(x)]"
+,wN);q4
+Lla;}
+qH
+TailCall_cSub:g5
+cSub
+hH
+wB(76,"cDup"
+aW,"[Value_t()]"
+wH,);q4
+Leh
+oF
+wB(200,qC1
+aW,"cAdd"
+,);q4
+Llb
+gY
+g8)){wB(58,"x[x==Value_t()]"
+aW,,wN);q4
+Lba;}
+m9(106,aY"x"
+aW,"[y-x]"
+,q81);q4
+Llc;}
+wB(51,"x"
+aW,"[-x]"
+aZ,wN);q4
+Lld
+gR
+w0
+oY
+cRSub
+dV
+wB(289,"x"
+mE
+a3"cSub"
+,"A"
+aZ" [x]"
+mE,aI(A)qD1
+wM);q4
+Lle;}
+wB(296,a6
+a3"cSub"
+,"[DO_STACKPLUS1] A"
+aW
+mE,aI(A)wM);incStackPtr();--mStackPtr;q4
+Llf;}
+qG
+TailCall_cTan:g5
+cTan:qS
+cAtan2:wB(354,"cAtan2 "
+mR,"cDiv"
+,);q4
+Lga
+oF
+wB(242,m0
+mR,mR
+aA,);q4
+Llg
+gY
+wB(187,"x "
+mR,"[fp_tan(x)]"
+,wN);q4
+Llh;oH
+qN
+oY
+cCot
+q11(501,aK" cCot "
+wI
+mR,"B cCot "
+aT,aI(A)q91(B)wM);q4
+Lcb;}
+}
+qG
+TailCall_cTanh:g5
+cTanh:qS
+cAtanh:wB(352,"cAtanh cTanh"
+,,);q4
+oE
+wB(243,m0"cTanh"
+,"cTanh"
+aA,);q4
+Lli
+gY
+wB(188,"x cTanh"
+,"[fp_tanh(x)]"
+,wN);q4
+Llj;}
+qH
+TailCall_cTrunc:g5
+cTrunc:qS
+hM
+wB(138,"x cTrunc"
+,"[fp_trunc(x)]"
+,wN);q4
+Llk
+gS
+wB(394,"A[IsAlwaysIntegerOpcode(A)] cTrunc"
+,"A"
+,aI(A)wM);gJ
+qG
+g7
+Default0:;A=w5
+w1
+0){B=q0[0
+hZ
+wB(475,aK" A[IsVarOpcode(A)&&mData->mByteCode.size()>0]"
+,"B"
+mQ,aI(A)q91(B)wM);q4
+Lll;}
+}
+if(gV
+h2
+B=dF
+qO
+B
+qP
+1){C=qK
+qR
+C==A){D
+g4
+D==B){wB(476,"D[D==B] C[C==A] B[IsVarOpcode(B)&&mData->mByteCode.size()>1] A[IsUnaryOpcode(A)]"
+,"D C"
+mQ,aI(A)q91(B)<<", C"
+wY(C)<<", D"
+wY(D)wM);q4
+Llm;}
+}
+}
+}
+C=w5
+qR
+IsCommutativeOrParamSwappableBinaryOpcode(C)){qS
+cSin:A=qK
+w1
+3
+gA]==cCos){B=hQ
+wB(505,aK" "
+aO" A[IsVarOpcode(A)&&mData->mByteCode.size()>3] "
+mP" C[IsCommutativeOrParamSwappableBinaryOpcode(C)]"
+,"B cSinCos {GetParamSwappedBinaryOpcode(C)}"
+," with C"
+wY(C)qE1(A)q91(B)wM);q4
+Lln;}
+}
+qT
+oQ
+A=qK
+w1
+3
+gA]==cCosh){B=hQ
+wB(506,aK" "
+aM" A[IsVarOpcode(A)&&mData->mByteCode.size()>3] cSinh C[IsCommutativeOrParamSwappableBinaryOpcode(C)]"
+,"B cSinhCosh {GetParamSwappedBinaryOpcode(C)}"
+," with C"
+wY(C)qE1(A)q91(B)wM);q4
+Llo;}
+}
+h8}
+}
+}
+q4
+Laa;Laa:qW
+w5);gJ
+Lab:g6
+Llp:wE(cAbs);q4
+TailCall_cAbs;Lac:q7=dP;gJ
+Lad:q7=fp_acos
+m6
+Lae:q7=fp_acosh
+m6
+Laf:oZ
+4));gG
+Llq:w5=h3;Lma:g0
+Lmb:wE(cMul);q4
+TailCall_cMul;Lag:hV
+4
+dT
+oZ
+4));Lmc:qW
+q6
+hY;Lah:q7=x+g1
+1);gG
+Lfb:w5=h3;q4
+Lmb;Lai:gU
+cSub;Lmd:wE(cSub);q4
+TailCall_cSub;Laj:hW
+2
+gH
+Lme:g0
+Lmf:wE(cAdd);q4
+TailCall_cAdd;Lak:hW
+oR
+Lmg:qE
+hS);Lmh:w5=cRSub;g0
+wE(cRSub);q4
+TailCall_cRSub;Lal:o9;qL
+2
+gK
+q4
+Lmg;Lam:hW
+2
+gH
+q4
+Lmh;Lan:hW
+4
+gH
+Lmi:qE
+hS);Lmj:qE
+B);Lmk:w5=cSub;g0
+q4
+Lmd;Lao:o9;oC=q6
+q9
+oR
+q4
+Lmi;Lap:hW
+oR
+q4
+Lmj;Laq:gT
+y+x;Lba:qM
+Lbo:q5
+gJ
+Lbb:q8
+oV
+o7
+x
+q71
+gX
+Lmg;Lbc:mM
+A
+gX
+Lmg;Lbd:gU
+dS;wE(cNotNot);q4
+TailCall_cNotNot;Lbe:gT
+fp_and(x
+d6
+Lbf:q7=fp_arg
+m6
+Lbg:q7=fp_asin
+m6
+Lbh:q7=fp_asinh
+m6
+Lbi:q7=fp_atan
+m6
+Lbj:gT
+fp_atan2(gW
+Lbk:q7=fp_atanh
+m6
+Lbl:q7=fp_cbrt
+m6
+Lbm:q1
+cFloor);Lml:w5=cNeg;g0
+wE(cNeg);q4
+TailCall_cNeg;Lbn:q7=fp_ceil
+m6
+Lbp:q7=fp_conj
+m6
+Lbq:g6
+Lmm:wE(cCos);q4
+TailCall_cCos;Lca:q7=fp_cos
+m6
+Lcb:dF=cDup;w5=cInv;Lmn:wE(cInv);q4
+TailCall_cInv;Lcc:mM
+cSinCos);gJ
+Lcd:q1
+cSqr
+o7
+g1
+1));Lmo:qW
+q6
+oJ
+hS);Lmp:w5=cSqrt;g0
+wE(cSqrt);q4
+TailCall_cSqrt;Lce:g6
+wE(cCosh);q4
+TailCall_cCosh;Lcf:q7=fp_cosh
+m6
+Lcg:mM
+cSinhCosh);gJ
+Lch:q7=RadiansToDegrees
+m6
+Lci:q1
+cSec
+hY;Lcj:q1
+cTan
+hY;Lck:q1
+cSin
+hY;Lcl:oZ));dF
+dJ
+Lmq:qE
+dU
+oZ
+1));Lna:qW
+q6);Lnb:w5=hS;q4
+Lme;Lcm:q1
+cNeg
+oJ
+cExp
+hY;Lcn:q1
+cNeg
+oJ
+cExp2
+hY;Lco:g6
+q4
+Lfb;Lcp:q1
+cNeg
+oJ
+cPow
+hY;Lcq:q1
+cCos
+hY;Lda:q1
+cCsc
+hY;Ldb:gU
+cTan;Lnc:wE(cTan);q4
+TailCall_cTan;Ldc:gU
+cTanh;Lnd:wE(cTanh);q4
+TailCall_cTanh;Ldd:q1
+cCot
+hY;Lde:o9;dI
+Lne:wE(cDiv);q4
+TailCall_cDiv;Ldf:gT
+y/x;q4
+Lba;Ldg:qF1
+q8
+oR
+Lnf:w5=cDeg;g0
+wE(cDeg);q4
+TailCall_cDeg;Ldh:qF1
+q8
+oR
+Lng:w5=cRad;g0
+wE(cRad);q4
+TailCall_cRad;Ldi:gT
+y/x;dG
+Llq;Ldj:q7=g1
+1)/x;q4
+Lfb;Ldk:mM
+oI
+Lnh:g0
+q4
+Lne;Ldl:q8
+3
+gC
+oI
+qF
+x
+q71);Lni:w5=cRDiv;g0
+wE(cRDiv);q4
+TailCall_cRDiv;Ldm:hV
+3
+gC
+oI
+qE
+B
+gX
+Lni;Ldn:dI
+Lnj:wE(cEqual);q4
+TailCall_cEqual;Ldo:gT
+fp_equal(gW
+Ldp:d7
+cExp
+o7
+fp_exp(x)gX
+Lmc;Ldq:q7=fp_exp
+m6
+Lea:d7
+cExp2
+o7
+fp_exp2(x)gX
+Lmc;Leb:q7=fp_exp2
+m6
+Lec:qF
+oW
+g1
+2))q71);Lnk:qE
+h3
+gI
+cExp;g0
+wE(cExp);q4
+TailCall_cExp;Led:q1
+cCeil
+oT
+Lee:q7=fp_floor
+m6
+Lef:gT
+fp_less(x
+d6
+Leg:gT
+fp_lessOrEq(x
+d6
+Leh:oZ));Lnl:dF
+dJ
+q4
+Llq;Lei:q7=fp_imag
+m6
+Lej:q7=fp_int
+m6
+Lek:gU
+cSec;wE(cSec);q4
+TailCall_cSec;Lel:gU
+cSin;Lnm:wE(cSin);q4
+TailCall_cSin;Lem:q1
+cNeg
+gI
+cPow;Lnn:g0
+Lno:wE(cPow);q4
+TailCall_cPow;Len:gU
+cCos;q4
+Lmm;Leo:gU
+cCsc;wE(cCsc);q4
+TailCall_cCsc;Lep:q1
+cRSqrt);gJ
+Leq:g6
+Lnp:w5=cCot;wE(cCot);q4
+TailCall_cCot;Lfa:q7=g1
+1)/x;gJ
+Lfc:gT
+fp_less(gW
+Lfd:gT
+fp_lessOrEq(gW
+Lfe:d7
+cLog
+o7
+oW
+x)gX
+Lna;Lff:q7=oW
+x);gJ
+Lfg:qF
+dR
+fp_const_e<dH>())gX
+Lnl;Lfh:d7
+cLog10
+o7
+dR
+x)gX
+Lna;Lfi:q7=dR
+x);gJ
+Lfj:qF
+o4
+fp_const_e<dH>())gX
+Lnl;Lfk:d7
+cLog2
+o7
+o4
+x)gX
+Lna;Lfl:q7=o4
+x);gJ
+Lfm:gT
+fp_max(x
+d6
+Lfn:gT
+fp_min(x
+d6
+Lfo:gT
+fp_mod(gW
+Lfp:hV
+oR
+q0-=3;q4
+Lnp;Lfq:gU
+cSqr;Lnq:wE(cSqr);q4
+TailCall_cSqr;Lga:gU
+cDiv;q4
+Lne;Lgb:mM
+cSqr
+oT
+Lgc:hV
+3
+gC
+cSqr);dM
+Lml;Lgd:q7=x+g1
+1);gG
+w5=cPow;q4
+Lno;Lge:gG
+q4
+Lmb;Lgf:gT
+x;Loa:dG
+Lma;Lgg:qF1
+qM
+Lob:hV
+4
+gH
+Loc:o6
+x);Lod:qW
+q6
+gX
+Lma;Lgh:qM
+q4
+Lob;Lgi:q8
+4
+gC
+B
+gX
+Loc;Lgj:q8
+oR
+q4
+Loc;Lgk:qK
+dJ
+oS;Lgl:dI
+q4
+Lmb;Lgm:qM
+Loe:hV
+oR
+gJ
+Lgn:q7=x+x;q4
+Lge;Lgo:gT
+x;qL
+4]dJ
+q8
+4
+dT
+o6
+y*x
+q71);dM
+Lnb;Lgp:gT
+x;d7
+dU
+qF
+y*x
+gX
+Lna;Lgq:q7=RadiansToDegrees(x
+gX
+Lgl;Lha:qG1
+q8
+4
+gH
+Lof:qE
+dU
+Log:qE
+B
+gI
+cDiv;q4
+Lnh;Lhb:o9;oC=q6
+q9
+oR
+q4
+Lof;Lhc:qG1
+q8
+oR
+q4
+Log;Lhd:q8
+4
+gH
+q4
+Lma;Lhe:q8
+4
+dT
+qF
+x+x
+gX
+Lod;Lhf:qF1
+qM
+q4
+Loe;Lhg:qG1
+q4
+Loa;Lhh:o9;q4
+Lgl;Lhi:qG1
+q8
+oR
+Loh:dM
+Lni;Lhj:o9;qL
+2
+gK
+q4
+Loh;Lhk:qG1
+dG
+Lni;Lhl:q7=h4
+gX
+Lgl;Lhm:gT
+x;qL
+4]dJ
+q8
+4
+dT
+o6
+y*x
+q71);dM
+Lmk;Lhn:qG1
+q4
+Lba;Lho:qM
+w3
+Lml;Lhp:dF=cDup;dW-=1;qM
+Loi:w5=hS;q4
+Lmf;Lhq:qM
+w3
+Lnf;Lia:qM
+w3
+Lng;Lib:hV
+oV
+gX
+Lof;Lic:hV
+2
+gH
+Loj:qE
+cSqr
+gX
+Lma;Lid:q8
+oV
+o7
+x
+q71
+gX
+Loh;Lie:mM
+A
+gX
+Loh;Lif:hV
+oR
+q4
+Loj;Lig:dI
+Lok:wE(cNEqual);q4
+TailCall_cNEqual;Lih:gT
+fp_nequal(gW
+Lii:o9;q4
+Lco;Lij:o9
+gB
+cSin;g0
+q4
+Lnm;Lik:o9
+gB
+cSinh;g0
+wE(cSinh);q4
+TailCall_cSinh;Lil:o9
+gB
+cTan;g0
+q4
+Lnc;Lim:o9
+gB
+cTanh;g0
+q4
+Lnd;Lin:o9;gJ
+Lio:q1
+cAbsNot);gJ
+Lip:gU
+cNEqual;q4
+Lok;Liq:gU
+cLessOrEq;wE(cLessOrEq);q4
+TailCall_cLessOrEq;Lja:gU
+cLess;wE(cLess);q4
+TailCall_cLess;Ljb:gU
+dK;wE(cGreaterOrEq);q4
+TailCall_cGreaterOrEq;Ljc:gU
+o1;wE(cGreater);q4
+TailCall_cGreater;Ljd:gU
+w8;q4
+Lnj;Lje:g6
+wE(cNot);q4
+TailCall_cNot;Ljf:q7=fp_not
+m6
+Ljg:gT
+fp_or(x
+d6
+Ljh:gT
+fp_polar(x
+d6
+Lji:dL
+Lnk;Ljj:qK=d8
+cExp2;g0
+wE(cExp2);q4
+TailCall_cExp2;Ljk:qG1
+dG
+Lnn;Ljl:qK
+dJ
+q1
+h3
+gX
+Lnn;Ljm:q7=g1
+gX
+Lmq;Ljn:qM
+w3
+Lmp;Ljo:qM
+q5
+w5=cCbrt;g0
+wE(cCbrt);q4
+TailCall_cCbrt;Ljp:qM
+q1
+cCbrt);Lol:w5=cInv;g0
+q4
+Lmn;Ljq:qM
+q4
+Lep;Lka:qM
+w3
+Lol;Lkb:q7=x+x;dI
+q4
+Lno;Lkc:gT
+oX
+gW
+Lkd:q1
+cTanh
+gX
+Lol;Lke:q7=h4
+gX
+Lco;Lkf:q7=h4);gJ
+Lkg:q7=fp_real
+m6
+Lkh:mM
+cSinCos
+gX
+Lol;Lki:q1
+cSin
+oT
+Lkj:q7=fp_sin
+m6
+Lkk:q1
+cSqr
+o7
+g1-1)gX
+Lmo;Lkl:q1
+cSinh
+oT
+Lkm:q7=fp_sinh
+m6
+Lkn:g6
+q4
+Lnq;Lko:hV
+4
+gC
+A);Lom:w5=cHypot;g0
+wE(cHypot);q4
+TailCall_cHypot;Lkp:hV
+5
+gC
+A
+oJ
+B
+gX
+Lom;Lkq:gU
+cAbs;q4
+Llp;Lla:q7=fp_sqrt
+m6
+Llb:g6
+q4
+Loi;Llc:gT
+y-x;q4
+Lba;Lld:o9;q4
+Loi;Lle:q8
+oV
+oJ
+hS
+o7
+x
+q71
+gX
+Lmh;Llf:mM
+A
+oJ
+cSub
+gX
+Lmh;Llg:q1
+cTan
+oT
+Llh:q7=fp_tan
+m6
+Lli:q1
+cTanh
+oT
+Llj:q7=fp_tanh
+m6
+Llk:q7=fp_trunc
+m6
+Lll:qW
+cDup);gJ
+Llm:dF=cDup;gJ
+Lln:hV
+3
+gC
+cSinCos);Lon:qE
+GetParamSwappedBinaryOpcode(C));gJ
+Llo:hV
+3
+gC
+cSinhCosh
+gX
+Lon;gJ
+q4
+TailCall_cAcos;q4
+TailCall_cAcosh;q4
+TailCall_cAnd;q4
+TailCall_cArg;q4
+TailCall_cAsin;q4
+TailCall_cAsinh;q4
+TailCall_cAtan;q4
+TailCall_cAtan2;q4
+TailCall_cAtanh;q4
+TailCall_cCeil;q4
+TailCall_cConj;q4
+TailCall_cFloor;q4
+TailCall_cImag;q4
+TailCall_cInt;q4
+TailCall_cLog;q4
+TailCall_cLog10;q4
+TailCall_cLog2;q4
+TailCall_cMax;q4
+TailCall_cMin;q4
+TailCall_cMod;q4
+TailCall_cOr;q4
+TailCall_cPolar;q4
+TailCall_cRDiv;q4
+TailCall_cRad;q4
+TailCall_cReal;q4
+TailCall_cSec;q4
+TailCall_cSin;q4
+TailCall_cSinh;q4
+TailCall_cSqrt;q4
+TailCall_cSub;q4
+TailCall_cTan;q4
+TailCall_cTanh;q4
+TailCall_cTrunc;
+#endif
+#undef FP_ReDefinePointers
+#undef FP_TRACE_BYTECODE_OPTIMIZATION
+#undef FP_TRACE_OPCODENAME
diff --git a/extrasrc/fpaux.hh b/extrasrc/fpaux.hh
new file mode 100644
index 0000000..f035c33
--- /dev/null
+++ b/extrasrc/fpaux.hh
@@ -0,0 +1,1249 @@
+/***************************************************************************\
+|* Function Parser for C++ v4.5.2 *|
+|*-------------------------------------------------------------------------*|
+|* Copyright: Juha Nieminen, 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 only internal types for the function parser library.
+// You don't need to include this file in your code. Include "fparser.hh"
+// only.
+
+#ifndef ONCE_FPARSER_AUX_H_
+#define ONCE_FPARSER_AUX_H_
+
+#include "fptypes.hh"
+
+#include <cmath>
+
+#ifdef FP_SUPPORT_MPFR_FLOAT_TYPE
+#include "mpfr/MpfrFloat.hh"
+#endif
+
+#ifdef FP_SUPPORT_GMP_INT_TYPE
+#include "mpfr/GmpInt.hh"
+#endif
+
+#ifdef FP_SUPPORT_COMPLEX_NUMBERS
+#include <complex>
+#endif
+
+#ifdef ONCE_FPARSER_H_
+namespace FUNCTIONPARSERTYPES
+{
+ template<typename>
+ struct IsIntType
+ {
+ enum { result = false };
+ };
+ template<>
+ struct IsIntType<long>
+ {
+ enum { result = true };
+ };
+#ifdef FP_SUPPORT_GMP_INT_TYPE
+ template<>
+ struct IsIntType<GmpInt>
+ {
+ enum { result = true };
+ };
+#endif
+
+ template<typename>
+ struct IsComplexType
+ {
+ enum { result = false };
+ };
+#ifdef FP_SUPPORT_COMPLEX_NUMBERS
+ template<typename T>
+ struct IsComplexType<std::complex<T> >
+ {
+ enum { result = true };
+ };
+#endif
+
+
+//==========================================================================
+// Constants
+//==========================================================================
+ template<typename Value_t>
+ inline Value_t fp_const_pi() // CONSTANT_PI
+ {
+ return Value_t(3.1415926535897932384626433832795028841971693993751L);
+ }
+
+ template<typename Value_t>
+ inline Value_t fp_const_e() // CONSTANT_E
+ {
+ return Value_t(2.7182818284590452353602874713526624977572L);
+ }
+ template<typename Value_t>
+ inline Value_t fp_const_einv() // CONSTANT_EI
+ {
+ return Value_t(0.367879441171442321595523770161460867445811131L);
+ }
+ template<typename Value_t>
+ inline Value_t fp_const_log2() // CONSTANT_L2, CONSTANT_L2EI
+ {
+ return Value_t(0.69314718055994530941723212145817656807550013436025525412L);
+ }
+ template<typename Value_t>
+ inline Value_t fp_const_log10() // CONSTANT_L10, CONSTANT_L10EI
+ {
+ return Value_t(2.302585092994045684017991454684364207601101488628772976L);
+ }
+ template<typename Value_t>
+ inline Value_t fp_const_log2inv() // CONSTANT_L2I, CONSTANT_L2E
+ {
+ return Value_t(1.442695040888963407359924681001892137426645954L);
+ }
+ template<typename Value_t>
+ inline Value_t fp_const_log10inv() // CONSTANT_L10I, CONSTANT_L10E
+ {
+ return Value_t(0.434294481903251827651128918916605082294397L);
+ }
+
+ template<typename Value_t>
+ inline const Value_t& fp_const_deg_to_rad() // CONSTANT_DR
+ {
+ static const Value_t factor = fp_const_pi<Value_t>() / Value_t(180); // to rad from deg
+ return factor;
+ }
+
+ template<typename Value_t>
+ inline const Value_t& fp_const_rad_to_deg() // CONSTANT_RD
+ {
+ static const Value_t factor = Value_t(180) / fp_const_pi<Value_t>(); // to deg from rad
+ return factor;
+ }
+
+#ifdef FP_SUPPORT_MPFR_FLOAT_TYPE
+ template<>
+ inline MpfrFloat fp_const_pi<MpfrFloat>() { return MpfrFloat::const_pi(); }
+
+ template<>
+ inline MpfrFloat fp_const_e<MpfrFloat>() { return MpfrFloat::const_e(); }
+
+ template<>
+ inline MpfrFloat fp_const_einv<MpfrFloat>() { return MpfrFloat(1) / MpfrFloat::const_e(); }
+
+ template<>
+ inline MpfrFloat fp_const_log2<MpfrFloat>() { return MpfrFloat::const_log2(); }
+
+ /*
+ template<>
+ inline MpfrFloat fp_const_log10<MpfrFloat>() { return fp_log(MpfrFloat(10)); }
+
+ template<>
+ inline MpfrFloat fp_const_log2inv<MpfrFloat>() { return MpfrFloat(1) / MpfrFloat::const_log2(); }
+
+ template<>
+ inline MpfrFloat fp_const_log10inv<MpfrFloat>() { return fp_log10(MpfrFloat::const_e()); }
+ */
+#endif
+
+
+//==========================================================================
+// Generic math functions
+//==========================================================================
+ template<typename Value_t>
+ inline Value_t fp_abs(const Value_t& x) { return std::fabs(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_acos(const Value_t& x) { return std::acos(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_asin(const Value_t& x) { return std::asin(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_atan(const Value_t& x) { return std::atan(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_atan2(const Value_t& x, const Value_t& y)
+ { return std::atan2(x, y); }
+
+ template<typename Value_t>
+ inline Value_t fp_ceil(const Value_t& x) { return std::ceil(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_cos(const Value_t& x) { return std::cos(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_cosh(const Value_t& x) { return std::cosh(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_exp(const Value_t& x) { return std::exp(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_floor(const Value_t& x) { return std::floor(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_log(const Value_t& x) { return std::log(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_mod(const Value_t& x, const Value_t& y)
+ { return std::fmod(x, y); }
+
+ template<typename Value_t>
+ inline Value_t fp_sin(const Value_t& x) { return std::sin(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_sinh(const Value_t& x) { return std::sinh(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_sqrt(const Value_t& x) { return std::sqrt(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_tan(const Value_t& x) { return std::tan(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_tanh(const Value_t& x) { return std::tanh(x); }
+
+#ifdef FP_SUPPORT_CPLUSPLUS11_MATH_FUNCS
+ template<typename Value_t>
+ inline Value_t fp_asinh(const Value_t& x) { return std::asinh(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_acosh(const Value_t& x) { return std::acosh(x); }
+
+ template<typename Value_t>
+ inline Value_t fp_atanh(const Value_t& x) { return std::atanh(x); }
+#else
+ template<typename Value_t>
+ inline Value_t fp_asinh(const Value_t& x)
+ { return fp_log(x + fp_sqrt(x*x + Value_t(1))); }
+
+ template<typename Value_t>
+ inline Value_t fp_acosh(const Value_t& x)
+ { return fp_log(x + fp_sqrt(x*x - Value_t(1))); }
+
+ template<typename Value_t>
+ inline Value_t fp_atanh(const Value_t& x)
+ {
+ return fp_log( (Value_t(1)+x) / (Value_t(1)-x)) * Value_t(0.5);
+ // Note: x = +1 causes division by zero
+ // x = -1 causes log(0)
+ // Thus, x must not be +-1
+ }
+#endif // FP_SUPPORT_ASINH
+
+#ifdef FP_SUPPORT_CPLUSPLUS11_MATH_FUNCS
+ template<typename Value_t>
+ inline Value_t fp_hypot(const Value_t& x, const Value_t& y)
+ { return std::hypot(x,y); }
+
+ template<typename Value_t>
+ inline std::complex<Value_t> fp_hypot
+ (const std::complex<Value_t>& x, const std::complex<Value_t>& y)
+ { return fp_sqrt(x*x + y*y); }
+#else
+ template<typename Value_t>
+ inline Value_t fp_hypot(const Value_t& x, const Value_t& y)
+ { return fp_sqrt(x*x + y*y); }
+#endif
+
+ template<typename Value_t>
+ inline Value_t fp_pow_base(const Value_t& x, const Value_t& y)
+ { return std::pow(x, y); }
+
+#ifdef FP_SUPPORT_CPLUSPLUS11_MATH_FUNCS
+ template<typename Value_t>
+ inline Value_t fp_log2(const Value_t& x) { return std::log2(x); }
+
+ template<typename Value_t>
+ inline std::complex<Value_t> fp_log2(const std::complex<Value_t>& x)
+ {
+ return fp_log(x) * fp_const_log2inv<Value_t>();
+ }
+#else
+ template<typename Value_t>
+ inline Value_t fp_log2(const Value_t& x)
+ {
+ return fp_log(x) * fp_const_log2inv<Value_t>();
+ }
+#endif // FP_SUPPORT_LOG2
+
+ template<typename Value_t>
+ inline Value_t fp_log10(const Value_t& x)
+ {
+ return fp_log(x) * fp_const_log10inv<Value_t>();
+ }
+
+ template<typename Value_t>
+ inline Value_t fp_trunc(const Value_t& x)
+ {
+ return x < Value_t() ? fp_ceil(x) : fp_floor(x);
+ }
+
+ template<typename Value_t>
+ inline Value_t fp_int(const Value_t& x)
+ {
+ return x < Value_t() ?
+ fp_ceil(x - Value_t(0.5)) : fp_floor(x + Value_t(0.5));
+ }
+
+ template<typename Value_t>
+ inline void fp_sinCos(Value_t& sinvalue, Value_t& cosvalue,
+ const Value_t& param)
+ {
+ // Assuming that "cosvalue" and "param" do not
+ // overlap, but "sinvalue" and "param" may.
+ cosvalue = fp_cos(param);
+ sinvalue = fp_sin(param);
+ }
+
+ template<typename Value_t>
+ inline void fp_sinhCosh(Value_t& sinhvalue, Value_t& coshvalue,
+ const Value_t& param)
+ {
+ const Value_t ex(fp_exp(param)), emx(fp_exp(-param));
+ sinhvalue = Value_t(0.5)*(ex-emx);
+ coshvalue = Value_t(0.5)*(ex+emx);
+ }
+
+ template<typename Value_t>
+ struct Epsilon
+ {
+ static Value_t value;
+ static Value_t defaultValue() { return 0; }
+ };
+
+ template<> inline double Epsilon<double>::defaultValue() { return 1E-12; }
+ template<> inline float Epsilon<float>::defaultValue() { return 1E-5F; }
+ template<> inline long double Epsilon<long double>::defaultValue() { return 1E-14L; }
+
+ template<> inline std::complex<double>
+ Epsilon<std::complex<double> >::defaultValue() { return 1E-12; }
+
+ template<> inline std::complex<float>
+ Epsilon<std::complex<float> >::defaultValue() { return 1E-5F; }
+
+ template<> inline std::complex<long double>
+ Epsilon<std::complex<long double> >::defaultValue() { return 1E-14L; }
+
+#ifdef FP_SUPPORT_MPFR_FLOAT_TYPE
+ template<> inline MpfrFloat
+ Epsilon<MpfrFloat>::defaultValue() { return MpfrFloat::someEpsilon(); }
+#endif
+
+ template<typename Value_t> Value_t Epsilon<Value_t>::value =
+ Epsilon<Value_t>::defaultValue();
+
+
+#ifdef _GNU_SOURCE
+ inline void fp_sinCos(double& sin, double& cos, const double& a)
+ {
+ sincos(a, &sin, &cos);
+ }
+ inline void fp_sinCos(float& sin, float& cos, const float& a)
+ {
+ sincosf(a, &sin, &cos);
+ }
+ inline void fp_sinCos(long double& sin, long double& cos,
+ const long double& a)
+ {
+ sincosl(a, &sin, &cos);
+ }
+#endif
+
+
+// -------------------------------------------------------------------------
+// Long int
+// -------------------------------------------------------------------------
+ inline long fp_abs(const long& x) { return x < 0 ? -x : x; }
+ inline long fp_acos(const long&) { return 0; }
+ inline long fp_asin(const long&) { return 0; }
+ inline long fp_atan(const long&) { return 0; }
+ inline long fp_atan2(const long&, const long&) { return 0; }
+ inline long fp_cbrt(const long&) { return 0; }
+ inline long fp_ceil(const long& x) { return x; }
+ inline long fp_cos(const long&) { return 0; }
+ inline long fp_cosh(const long&) { return 0; }
+ inline long fp_exp(const long&) { return 0; }
+ inline long fp_exp2(const long&) { return 0; }
+ inline long fp_floor(const long& x) { return x; }
+ inline long fp_log(const long&) { return 0; }
+ inline long fp_log2(const long&) { return 0; }
+ inline long fp_log10(const long&) { return 0; }
+ inline long fp_mod(const long& x, const long& y) { return x % y; }
+ inline long fp_pow(const long&, const long&) { return 0; }
+ inline long fp_sin(const long&) { return 0; }
+ inline long fp_sinh(const long&) { return 0; }
+ inline long fp_sqrt(const long&) { return 1; }
+ inline long fp_tan(const long&) { return 0; }
+ inline long fp_tanh(const long&) { return 0; }
+ inline long fp_asinh(const long&) { return 0; }
+ inline long fp_acosh(const long&) { return 0; }
+ inline long fp_atanh(const long&) { return 0; }
+ inline long fp_pow_base(const long&, const long&) { return 0; }
+ inline void fp_sinCos(long&, long&, const long&) {}
+ inline void fp_sinhCosh(long&, long&, const long&) {}
+
+ //template<> inline long fp_epsilon<long>() { return 0; }
+
+
+// -------------------------------------------------------------------------
+// MpfrFloat
+// -------------------------------------------------------------------------
+#ifdef FP_SUPPORT_MPFR_FLOAT_TYPE
+ inline MpfrFloat fp_abs(const MpfrFloat& x) { return MpfrFloat::abs(x); }
+ inline MpfrFloat fp_acos(const MpfrFloat& x) { return MpfrFloat::acos(x); }
+ inline MpfrFloat fp_acosh(const MpfrFloat& x) { return MpfrFloat::acosh(x); }
+ inline MpfrFloat fp_asin(const MpfrFloat& x) { return MpfrFloat::asin(x); }
+ inline MpfrFloat fp_asinh(const MpfrFloat& x) { return MpfrFloat::asinh(x); }
+ inline MpfrFloat fp_atan(const MpfrFloat& x) { return MpfrFloat::atan(x); }
+ inline MpfrFloat fp_atan2(const MpfrFloat& x, const MpfrFloat& y)
+ { return MpfrFloat::atan2(x, y); }
+ inline MpfrFloat fp_atanh(const MpfrFloat& x) { return MpfrFloat::atanh(x); }
+ inline MpfrFloat fp_cbrt(const MpfrFloat& x) { return MpfrFloat::cbrt(x); }
+ inline MpfrFloat fp_ceil(const MpfrFloat& x) { return MpfrFloat::ceil(x); }
+ inline MpfrFloat fp_cos(const MpfrFloat& x) { return MpfrFloat::cos(x); }
+ inline MpfrFloat fp_cosh(const MpfrFloat& x) { return MpfrFloat::cosh(x); }
+ inline MpfrFloat fp_exp(const MpfrFloat& x) { return MpfrFloat::exp(x); }
+ inline MpfrFloat fp_exp2(const MpfrFloat& x) { return MpfrFloat::exp2(x); }
+ inline MpfrFloat fp_floor(const MpfrFloat& x) { return MpfrFloat::floor(x); }
+ inline MpfrFloat fp_hypot(const MpfrFloat& x, const MpfrFloat& y)
+ { return MpfrFloat::hypot(x, y); }
+ inline MpfrFloat fp_int(const MpfrFloat& x) { return MpfrFloat::round(x); }
+ inline MpfrFloat fp_log(const MpfrFloat& x) { return MpfrFloat::log(x); }
+ inline MpfrFloat fp_log2(const MpfrFloat& x) { return MpfrFloat::log2(x); }
+ inline MpfrFloat fp_log10(const MpfrFloat& x) { return MpfrFloat::log10(x); }
+ inline MpfrFloat fp_mod(const MpfrFloat& x, const MpfrFloat& y) { return x % y; }
+ inline MpfrFloat fp_sin(const MpfrFloat& x) { return MpfrFloat::sin(x); }
+ inline MpfrFloat fp_sinh(const MpfrFloat& x) { return MpfrFloat::sinh(x); }
+ inline MpfrFloat fp_sqrt(const MpfrFloat& x) { return MpfrFloat::sqrt(x); }
+ inline MpfrFloat fp_tan(const MpfrFloat& x) { return MpfrFloat::tan(x); }
+ inline MpfrFloat fp_tanh(const MpfrFloat& x) { return MpfrFloat::tanh(x); }
+ inline MpfrFloat fp_trunc(const MpfrFloat& x) { return MpfrFloat::trunc(x); }
+
+ inline MpfrFloat fp_pow(const MpfrFloat& x, const MpfrFloat& y) { return MpfrFloat::pow(x, y); }
+ inline MpfrFloat fp_pow_base(const MpfrFloat& x, const MpfrFloat& y) { return MpfrFloat::pow(x, y); }
+
+
+ inline void fp_sinCos(MpfrFloat& sin, MpfrFloat& cos, const MpfrFloat& a)
+ {
+ MpfrFloat::sincos(a, sin, cos);
+ }
+
+ inline void fp_sinhCosh(MpfrFloat& sinhvalue, MpfrFloat& coshvalue,
+ const MpfrFloat& param)
+ {
+ const MpfrFloat paramCopy = param;
+ sinhvalue = fp_sinh(paramCopy);
+ coshvalue = fp_cosh(paramCopy);
+ }
+#endif // FP_SUPPORT_MPFR_FLOAT_TYPE
+
+
+// -------------------------------------------------------------------------
+// GMP int
+// -------------------------------------------------------------------------
+#ifdef FP_SUPPORT_GMP_INT_TYPE
+ inline GmpInt fp_abs(const GmpInt& x) { return GmpInt::abs(x); }
+ inline GmpInt fp_acos(const GmpInt&) { return 0; }
+ inline GmpInt fp_acosh(const GmpInt&) { return 0; }
+ inline GmpInt fp_asin(const GmpInt&) { return 0; }
+ inline GmpInt fp_asinh(const GmpInt&) { return 0; }
+ inline GmpInt fp_atan(const GmpInt&) { return 0; }
+ inline GmpInt fp_atan2(const GmpInt&, const GmpInt&) { return 0; }
+ inline GmpInt fp_atanh(const GmpInt&) { return 0; }
+ inline GmpInt fp_cbrt(const GmpInt&) { return 0; }
+ inline GmpInt fp_ceil(const GmpInt& x) { return x; }
+ inline GmpInt fp_cos(const GmpInt&) { return 0; }
+ inline GmpInt fp_cosh(const GmpInt&) { return 0; }
+ inline GmpInt fp_exp(const GmpInt&) { return 0; }
+ inline GmpInt fp_exp2(const GmpInt&) { return 0; }
+ inline GmpInt fp_floor(const GmpInt& x) { return x; }
+ inline GmpInt fp_hypot(const GmpInt&, const GmpInt&) { return 0; }
+ inline GmpInt fp_int(const GmpInt& x) { return x; }
+ inline GmpInt fp_log(const GmpInt&) { return 0; }
+ inline GmpInt fp_log2(const GmpInt&) { return 0; }
+ inline GmpInt fp_log10(const GmpInt&) { return 0; }
+ inline GmpInt fp_mod(const GmpInt& x, const GmpInt& y) { return x % y; }
+ inline GmpInt fp_pow(const GmpInt&, const GmpInt&) { return 0; }
+ inline GmpInt fp_sin(const GmpInt&) { return 0; }
+ inline GmpInt fp_sinh(const GmpInt&) { return 0; }
+ inline GmpInt fp_sqrt(const GmpInt&) { return 0; }
+ inline GmpInt fp_tan(const GmpInt&) { return 0; }
+ inline GmpInt fp_tanh(const GmpInt&) { return 0; }
+ inline GmpInt fp_trunc(const GmpInt& x) { return x; }
+ inline GmpInt fp_pow_base(const GmpInt&, const GmpInt&) { return 0; }
+ inline void fp_sinCos(GmpInt&, GmpInt&, const GmpInt&) {}
+ inline void fp_sinhCosh(GmpInt&, GmpInt&, const GmpInt&) {}
+#endif // FP_SUPPORT_GMP_INT_TYPE
+
+
+#ifdef FP_SUPPORT_CPLUSPLUS11_MATH_FUNCS
+ template<typename Value_t>
+ inline Value_t fp_cbrt(const Value_t& x) { return std::cbrt(x); }
+#else
+ template<typename Value_t>
+ inline Value_t fp_cbrt(const Value_t& x)
+ {
+ return (x > Value_t() ? fp_exp(fp_log( x) / Value_t(3)) :
+ x < Value_t() ? -fp_exp(fp_log(-x) / Value_t(3)) :
+ Value_t());
+ }
+#endif
+
+// -------------------------------------------------------------------------
+// Synthetic functions and fallbacks for when an optimized
+// implementation or a library function is not available
+// -------------------------------------------------------------------------
+ template<typename Value_t> inline Value_t fp_arg(const Value_t& x);
+ template<typename Value_t> inline Value_t fp_exp2(const Value_t& x);
+ template<typename Value_t> inline Value_t fp_int(const Value_t& x);
+ template<typename Value_t> inline Value_t fp_trunc(const Value_t& x);
+ template<typename Value_t>
+ inline void fp_sinCos(Value_t& , Value_t& , const Value_t& );
+ template<typename Value_t>
+ inline void fp_sinhCosh(Value_t& , Value_t& , const Value_t& );
+
+#ifdef FP_SUPPORT_COMPLEX_NUMBERS
+ /* NOTE: Complex multiplication of a and b can be done with:
+ tmp = b.real * (a.real + a.imag)
+ result.real = tmp - a.imag * (b.real + b.imag)
+ result.imag = tmp + a.real * (b.imag - b.real)
+ This has fewer multiplications than the standard
+ algorithm. Take note, if you support mpfr complex one day.
+ */
+
+ template<typename T>
+ struct FP_ProbablyHasFastLibcComplex
+ { enum { result = false }; };
+ /* The generic sqrt() etc. implementations in libstdc++
+ * are very plain and non-optimized; however, it contains
+ * callbacks to libc complex math functions where possible,
+ * and I suspect that those may actually be well optimized.
+ * So we use std:: functions when we suspect they may be fast,
+ * and otherwise we use our own optimized implementations.
+ */
+#ifdef __GNUC__
+ template<> struct FP_ProbablyHasFastLibcComplex<float>
+ { enum { result = true }; };
+ template<> struct FP_ProbablyHasFastLibcComplex<double>
+ { enum { result = true }; };
+ template<> struct FP_ProbablyHasFastLibcComplex<long double>
+ { enum { result = true }; };
+#endif
+
+ template<typename T>
+ inline const std::complex<T> fp_make_imag(const std::complex<T>& v)
+ {
+ return std::complex<T> ( T(), v.real() );
+ }
+
+ template<typename T>
+ inline std::complex<T> fp_real(const std::complex<T>& x)
+ {
+ return x.real();
+ }
+ template<typename T>
+ inline std::complex<T> fp_imag(const std::complex<T>& x)
+ {
+ return x.imag();
+ }
+ template<typename T>
+ inline std::complex<T> fp_arg(const std::complex<T>& x)
+ {
+ return std::arg(x);
+ }
+ template<typename T>
+ inline std::complex<T> fp_conj(const std::complex<T>& x)
+ {
+ return std::conj(x);
+ }
+ template<typename T, bool>
+ inline std::complex<T> fp_polar(const T& x, const T& y)
+ {
+ T si, co; fp_sinCos(si, co, y);
+ return std::complex<T> (x*co, x*si);
+ }
+ template<typename T>
+ inline std::complex<T> fp_polar(const std::complex<T>& x, const std::complex<T>& y)
+ {
+ // x * cos(y) + i * x * sin(y) -- arguments are supposed to be REAL numbers
+ return fp_polar<T,true> (x.real(), y.real());
+ //return std::polar(x.real(), y.real());
+ //return x * (fp_cos(y) + (std::complex<T>(0,1) * fp_sin(y));
+ }
+
+ // These provide fallbacks in case there's no library function
+ template<typename T>
+ inline std::complex<T> fp_floor(const std::complex<T>& x)
+ {
+ return std::complex<T> (fp_floor(x.real()), fp_floor(x.imag()));
+ }
+ template<typename T>
+ inline std::complex<T> fp_trunc(const std::complex<T>& x)
+ {
+ return std::complex<T> (fp_trunc(x.real()), fp_trunc(x.imag()));
+ }
+ template<typename T>
+ inline std::complex<T> fp_int(const std::complex<T>& x)
+ {
+ return std::complex<T> (fp_int(x.real()), fp_int(x.imag()));
+ }
+ template<typename T>
+ inline std::complex<T> fp_ceil(const std::complex<T>& x)
+ {
+ return std::complex<T> (fp_ceil(x.real()), fp_ceil(x.imag()));
+ }
+ template<typename T>
+ inline std::complex<T> fp_abs(const std::complex<T>& x)
+ {
+ return std::abs(x);
+ //T extent = fp_max(fp_abs(x.real()), fp_abs(x.imag()));
+ //if(extent == T()) return x;
+ //return extent * fp_hypot(x.real() / extent, x.imag() / extent);
+ }
+ template<typename T>
+ inline std::complex<T> fp_exp(const std::complex<T>& x)
+ {
+ if(FP_ProbablyHasFastLibcComplex<T>::result)
+ return std::exp(x);
+ return fp_polar<T,true>(fp_exp(x.real()), x.imag());
+ }
+ template<typename T>
+ inline std::complex<T> fp_log(const std::complex<T>& x)
+ {
+ if(FP_ProbablyHasFastLibcComplex<T>::result)
+ return std::log(x);
+ // log(abs(x)) + i*arg(x)
+ // log(Xr^2+Xi^2)*0.5 + i*arg(x)
+ if(x.imag()==T())
+ return std::complex<T>( fp_log(fp_abs(x.real())),
+ fp_arg(x.real()) ); // Note: Uses real-value fp_arg() here!
+ return std::complex<T>(
+ fp_log(std::norm(x)) * T(0.5),
+ fp_arg(x).real() );
+ }
+ template<typename T>
+ inline std::complex<T> fp_sqrt(const std::complex<T>& x)
+ {
+ if(FP_ProbablyHasFastLibcComplex<T>::result)
+ return std::sqrt(x);
+ return fp_polar<T,true> (fp_sqrt(fp_abs(x).real()),
+ T(0.5)*fp_arg(x).real());
+ }
+ template<typename T>
+ inline std::complex<T> fp_acos(const std::complex<T>& x)
+ {
+ // -i * log(x + i * sqrt(1 - x^2))
+ const std::complex<T> i (T(), T(1));
+ return -i * fp_log(x + i * fp_sqrt(T(1) - x*x));
+ // Note: Real version of acos() cannot handle |x| > 1,
+ // because it would cause sqrt(negative value).
+ }
+ template<typename T>
+ inline std::complex<T> fp_asin(const std::complex<T>& x)
+ {
+ // -i * log(i*x + sqrt(1 - x^2))
+ const std::complex<T> i (T(), T(1));
+ return -i * fp_log(i*x + fp_sqrt(T(1) - x*x));
+ // Note: Real version of asin() cannot handle |x| > 1,
+ // because it would cause sqrt(negative value).
+ }
+ template<typename T>
+ inline std::complex<T> fp_atan(const std::complex<T>& x)
+ {
+ // 0.5i * (log(1-i*x) - log(1+i*x))
+ // -0.5i * log( (1+i*x) / (1-i*x) )
+ const std::complex<T> i (T(), T(1));
+ return (T(-0.5)*i) * fp_log( (T(1)+i*x) / (T(1)-i*x) );
+ // Note: x = -1i causes division by zero
+ // x = +1i causes log(0)
+ // Thus, x must not be +-1i
+ }
+ template<typename T>
+ inline std::complex<T> fp_cos(const std::complex<T>& x)
+ {
+ return std::cos(x);
+ // // (exp(i*x) + exp(-i*x)) / (2)
+ // //const std::complex<T> i (T(), T(1));
+ // //return (fp_exp(i*x) + fp_exp(-i*x)) * T(0.5);
+ // // Also: cos(Xr)*cosh(Xi) - i*sin(Xr)*sinh(Xi)
+ // return std::complex<T> (
+ // fp_cos(x.real())*fp_cosh(x.imag()),
+ // -fp_sin(x.real())*fp_sinh(x.imag()));
+ }
+ template<typename T>
+ inline std::complex<T> fp_sin(const std::complex<T>& x)
+ {
+ return std::sin(x);
+ // // (exp(i*x) - exp(-i*x)) / (2i)
+ // //const std::complex<T> i (T(), T(1));
+ // //return (fp_exp(i*x) - fp_exp(-i*x)) * (T(-0.5)*i);
+ // // Also: sin(Xr)*cosh(Xi) + cos(Xr)*sinh(Xi)
+ // return std::complex<T> (
+ // fp_sin(x.real())*fp_cosh(x.imag()),
+ // fp_cos(x.real())*fp_sinh(x.imag()));
+ }
+ template<typename T>
+ inline void fp_sinCos(
+ std::complex<T>& sinvalue,
+ std::complex<T>& cosvalue,
+ const std::complex<T>& x)
+ {
+ //const std::complex<T> i (T(), T(1)), expix(fp_exp(i*x)), expmix(fp_exp((-i)*x));
+ //cosvalue = (expix + expmix) * T(0.5);
+ //sinvalue = (expix - expmix) * (i*T(-0.5));
+ // The above expands to the following:
+ T srx, crx; fp_sinCos(srx, crx, x.real());
+ T six, cix; fp_sinhCosh(six, cix, x.imag());
+ sinvalue = std::complex<T>(srx*cix, crx*six);
+ cosvalue = std::complex<T>(crx*cix, -srx*six);
+ }
+ template<typename T>
+ inline void fp_sinhCosh(
+ std::complex<T>& sinhvalue,
+ std::complex<T>& coshvalue,
+ const std::complex<T>& x)
+ {
+ T srx, crx; fp_sinhCosh(srx, crx, x.real());
+ T six, cix; fp_sinCos(six, cix, x.imag());
+ sinhvalue = std::complex<T>(srx*cix, crx*six);
+ coshvalue = std::complex<T>(crx*cix, srx*six);
+ }
+ template<typename T>
+ inline std::complex<T> fp_tan(const std::complex<T>& x)
+ {
+ return std::tan(x);
+ //std::complex<T> si, co;
+ //fp_sinCos(si, co, x);
+ //return si/co;
+ // // (i-i*exp(2i*x)) / (exp(2i*x)+1)
+ // const std::complex<T> i (T(), T(1)), exp2ix=fp_exp((2*i)*x);
+ // return (i-i*exp2ix) / (exp2ix+T(1));
+ // // Also: sin(x)/cos(y)
+ // // return fp_sin(x)/fp_cos(x);
+ }
+ template<typename T>
+ inline std::complex<T> fp_cosh(const std::complex<T>& x)
+ {
+ return std::cosh(x);
+ // // (exp(x) + exp(-x)) * 0.5
+ // // Also: cosh(Xr)*cos(Xi) + i*sinh(Xr)*sin(Xi)
+ // return std::complex<T> (
+ // fp_cosh(x.real())*fp_cos(x.imag()),
+ // fp_sinh(x.real())*fp_sin(x.imag()));
+ }
+ template<typename T>
+ inline std::complex<T> fp_sinh(const std::complex<T>& x)
+ {
+ return std::sinh(x);
+ // // (exp(x) - exp(-x)) * 0.5
+ // // Also: sinh(Xr)*cos(Xi) + i*cosh(Xr)*sin(Xi)
+ // return std::complex<T> (
+ // fp_sinh(x.real())*fp_cos(x.imag()),
+ // fp_cosh(x.real())*fp_sin(x.imag()));
+ }
+ template<typename T>
+ inline std::complex<T> fp_tanh(const std::complex<T>& x)
+ {
+ return std::tanh(x);
+ //std::complex<T> si, co;
+ //fp_sinhCosh(si, co, x);
+ //return si/co;
+ // // (exp(2*x)-1) / (exp(2*x)+1)
+ // // Also: sinh(x)/tanh(x)
+ // const std::complex<T> exp2x=fp_exp(x+x);
+ // return (exp2x-T(1)) / (exp2x+T(1));
+ }
+
+#ifdef FP_SUPPORT_CPLUSPLUS11_MATH_FUNCS
+ template<typename T>
+ inline std::complex<T> fp_acosh(const std::complex<T>& x)
+ { return fp_log(x + fp_sqrt(x*x - std::complex<T>(1))); }
+ template<typename T>
+ inline std::complex<T> fp_asinh(const std::complex<T>& x)
+ { return fp_log(x + fp_sqrt(x*x + std::complex<T>(1))); }
+ template<typename T>
+ inline std::complex<T> fp_atanh(const std::complex<T>& x)
+ { return fp_log( (std::complex<T>(1)+x) / (std::complex<T>(1)-x))
+ * std::complex<T>(0.5); }
+#endif
+ template<typename T>
+ inline std::complex<T> fp_pow(const std::complex<T>& x, const std::complex<T>& y)
+ {
+ // return std::pow(x,y);
+
+ // With complex numbers, pow(x,y) can be solved with
+ // the general formula: exp(y*log(x)). It handles
+ // all special cases gracefully.
+ // It expands to the following:
+ // A)
+ // t1 = log(x)
+ // t2 = y * t1
+ // res = exp(t2)
+ // B)
+ // t1.r = log(x.r * x.r + x.i * x.i) * 0.5 \ fp_log()
+ // t1.i = atan2(x.i, x.r) /
+ // t2.r = y.r*t1.r - y.i*t1.i \ multiplication
+ // t2.i = y.r*t1.i + y.i*t1.r /
+ // rho = exp(t2.r) \ fp_exp()
+ // theta = t2.i /
+ // res.r = rho * cos(theta) \ fp_polar(), called from
+ // res.i = rho * sin(theta) / fp_exp(). Uses sincos().
+ // Aside from the common "norm" calculation in atan2()
+ // and in the log parameter, both of which are part of fp_log(),
+ // there does not seem to be any incentive to break this
+ // function down further; it would not help optimizing it.
+ // However, we do handle the following special cases:
+ //
+ // When x is real (positive or negative):
+ // t1.r = log(abs(x.r))
+ // t1.i = x.r<0 ? -pi : 0
+ // When y is real:
+ // t2.r = y.r * t1.r
+ // t2.i = y.r * t1.i
+ const std::complex<T> t =
+ (x.imag() != T())
+ ? fp_log(x)
+ : std::complex<T> (fp_log(fp_abs(x.real())),
+ fp_arg(x.real())); // Note: Uses real-value fp_arg() here!
+ return y.imag() != T()
+ ? fp_exp(y * t)
+ : fp_polar<T,true> (fp_exp(y.real()*t.real()), y.real()*t.imag());
+ }
+ template<typename T>
+ inline std::complex<T> fp_cbrt(const std::complex<T>& x)
+ {
+ // For real numbers, prefer giving a real solution
+ // rather than a complex solution.
+ // For example, cbrt(-3) has the following three solutions:
+ // A) 0.7211247966535 + 1.2490247864016i
+ // B) 0.7211247966535 - 1.2490247864016i
+ // C) -1.442249593307
+ // exp(log(x)/3) gives A, but we prefer to give C.
+ if(x.imag() == T()) return fp_cbrt(x.real());
+ const std::complex<T> t(fp_log(x));
+ return fp_polar<T,true> (fp_exp(t.real() / T(3)), t.imag() / T(3));
+ }
+
+ template<typename T>
+ inline std::complex<T> fp_exp2(const std::complex<T>& x)
+ {
+ // pow(2, x)
+ // polar(2^Xr, Xi*log(2))
+ return fp_polar<T,true> (fp_exp2(x.real()), x.imag()*fp_const_log2<T>());
+ }
+ template<typename T>
+ inline std::complex<T> fp_mod(const std::complex<T>& x, const std::complex<T>& y)
+ {
+ // Modulo function is probably not defined for complex numbers.
+ // But we do our best to calculate it the same way as it is done
+ // with real numbers, so that at least it is in some way "consistent".
+ if(y.imag() == 0) return fp_mod(x.real(), y.real()); // optimization
+ std::complex<T> n = fp_trunc(x / y);
+ return x - n * y;
+ }
+
+ /* libstdc++ already defines a streaming operator for complex values,
+ * but we redefine our own that it is compatible with the input
+ * accepted by fparser. I.e. instead of (5,3) we now get (5+3i),
+ * and instead of (-4,0) we now get -4.
+ */
+ template<typename T>
+ inline std::ostream& operator<<(std::ostream& os, const std::complex<T>& value)
+ {
+ if(value.imag() == T()) return os << value.real();
+ if(value.real() == T()) return os << value.imag() << 'i';
+ if(value.imag() < T())
+ return os << '(' << value.real() << "-" << -value.imag() << "i)";
+ else
+ return os << '(' << value.real() << "+" << value.imag() << "i)";
+ }
+
+ /* Less-than or greater-than operators are not technically defined
+ * for Complex types. However, in fparser and its tool set, these
+ * operators are widely required to be present.
+ * Our implementation here is based on converting the complex number
+ * into a scalar and the doing a scalar comparison on the value.
+ * The means by which the number is changed into a scalar is based
+ * on the following principles:
+ * - Does not introduce unjustified amounts of extra inaccuracy
+ * - Is transparent to purely real values
+ * (this disqualifies something like x.real() + x.imag())
+ * - Does not ignore the imaginary value completely
+ * (this may be relevant especially in testbed)
+ * - Is not so complicated that it would slow down a great deal
+ *
+ * Basically our formula here is the same as std::abs(),
+ * except that it keeps the sign of the original real number,
+ * and it does not do a sqrt() calculation that is not really
+ * needed because we are only interested in the relative magnitudes.
+ *
+ * Equality and nonequality operators must not need to be overloaded.
+ * They are already implemented in standard, and we must
+ * not introduce flawed equality assumptions.
+ */
+ template<typename T>
+ inline T fp_complexScalarize(const std::complex<T>& x)
+ {
+ T res(std::norm(x));
+ if(x.real() < T()) res = -res;
+ return res;
+ }
+ template<typename T>
+ inline T fp_realComplexScalarize(const T& x)
+ {
+ T res(x*x);
+ if(x < T()) res = -res;
+ return res;
+ }
+ // { return x.real() * (T(1.0) + fp_abs(x.imag())); }
+ #define d(op) \
+ template<typename T> \
+ inline bool operator op (const std::complex<T>& x, T y) \
+ { return fp_complexScalarize(x) op fp_realComplexScalarize(y); } \
+ template<typename T> \
+ inline bool operator op (const std::complex<T>& x, const std::complex<T>& y) \
+ { return fp_complexScalarize(x) op \
+ fp_complexScalarize(y); } \
+ template<typename T> \
+ inline bool operator op (T x, const std::complex<T>& y) \
+ { return fp_realComplexScalarize(x) op fp_complexScalarize(y); }
+ d( < ) d( <= ) d( > ) d( >= )
+ #undef d
+#endif
+
+ template<typename Value_t>
+ inline Value_t fp_real(const Value_t& x) { return x; }
+ template<typename Value_t>
+ inline Value_t fp_imag(const Value_t& ) { return Value_t(); }
+ template<typename Value_t>
+ inline Value_t fp_arg(const Value_t& x)
+ { return x < Value_t() ? -fp_const_pi<Value_t>() : Value_t(); }
+ template<typename Value_t>
+ inline Value_t fp_conj(const Value_t& x) { return x; }
+ template<typename Value_t>
+ inline Value_t fp_polar(const Value_t& x, const Value_t& y)
+ { return x * fp_cos(y); } // This is of course a meaningless function.
+
+ template<typename Value_t>
+ inline std::complex<Value_t> fp_atan2(const std::complex<Value_t>& y,
+ const std::complex<Value_t>& x)
+ {
+ if(y == Value_t()) return fp_arg(x);
+ if(x == Value_t()) return fp_const_pi<Value_t>() * Value_t(-0.5);
+ // 2*atan(y / (sqrt(x^2+y^2) + x) )
+ // 2*atan( (sqrt(x^2+y^2) - x) / y)
+ std::complex<Value_t> res( fp_atan(y / (fp_hypot(x,y) + x)) );
+ return res+res;
+ }
+
+// -------------------------------------------------------------------------
+// Comparison
+// -------------------------------------------------------------------------
+ template<typename Value_t>
+ inline bool fp_equal(const Value_t& x, const Value_t& y)
+ { return IsIntType<Value_t>::result
+ ? (x == y)
+ : (fp_abs(x - y) <= Epsilon<Value_t>::value); }
+
+ template<typename Value_t>
+ inline bool fp_nequal(const Value_t& x, const Value_t& y)
+ { return IsIntType<Value_t>::result
+ ? (x != y)
+ : (fp_abs(x - y) > Epsilon<Value_t>::value); }
+
+ template<typename Value_t>
+ inline bool fp_less(const Value_t& x, const Value_t& y)
+ { return IsIntType<Value_t>::result
+ ? (x < y)
+ : (x < y - Epsilon<Value_t>::value); }
+
+ template<typename Value_t>
+ inline bool fp_lessOrEq(const Value_t& x, const Value_t& y)
+ { return IsIntType<Value_t>::result
+ ? (x <= y)
+ : (x <= y + Epsilon<Value_t>::value); }
+
+
+ template<typename Value_t>
+ inline bool fp_greater(const Value_t& x, const Value_t& y)
+ { return fp_less(y, x); }
+
+ template<typename Value_t>
+ inline bool fp_greaterOrEq(const Value_t& x, const Value_t& y)
+ { return fp_lessOrEq(y, x); }
+
+ template<typename Value_t>
+ inline bool fp_truth(const Value_t& d)
+ {
+ return IsIntType<Value_t>::result
+ ? d != Value_t()
+ : fp_abs(d) >= Value_t(0.5);
+ }
+
+ template<typename Value_t>
+ inline bool fp_absTruth(const Value_t& abs_d)
+ {
+ return IsIntType<Value_t>::result
+ ? abs_d > Value_t()
+ : abs_d >= Value_t(0.5);
+ }
+
+ template<typename Value_t>
+ inline const Value_t& fp_min(const Value_t& d1, const Value_t& d2)
+ { return d1<d2 ? d1 : d2; }
+
+ template<typename Value_t>
+ inline const Value_t& fp_max(const Value_t& d1, const Value_t& d2)
+ { return d1>d2 ? d1 : d2; }
+
+ template<typename Value_t>
+ inline const Value_t fp_not(const Value_t& b)
+ { return Value_t(!fp_truth(b)); }
+
+ template<typename Value_t>
+ inline const Value_t fp_notNot(const Value_t& b)
+ { return Value_t(fp_truth(b)); }
+
+ template<typename Value_t>
+ inline const Value_t fp_absNot(const Value_t& b)
+ { return Value_t(!fp_absTruth(b)); }
+
+ template<typename Value_t>
+ inline const Value_t fp_absNotNot(const Value_t& b)
+ { return Value_t(fp_absTruth(b)); }
+
+ template<typename Value_t>
+ inline const Value_t fp_and(const Value_t& a, const Value_t& b)
+ { return Value_t(fp_truth(a) && fp_truth(b)); }
+
+ template<typename Value_t>
+ inline const Value_t fp_or(const Value_t& a, const Value_t& b)
+ { return Value_t(fp_truth(a) || fp_truth(b)); }
+
+ template<typename Value_t>
+ inline const Value_t fp_absAnd(const Value_t& a, const Value_t& b)
+ { return Value_t(fp_absTruth(a) && fp_absTruth(b)); }
+
+ template<typename Value_t>
+ inline const Value_t fp_absOr(const Value_t& a, const Value_t& b)
+ { return Value_t(fp_absTruth(a) || fp_absTruth(b)); }
+
+ template<typename Value_t>
+ inline const Value_t fp_make_imag(const Value_t& ) // Imaginary 1. In real mode, always zero.
+ {
+ return Value_t();
+ }
+
+ /////////////
+ /* Opcode analysis functions are used by fp_opcode_add.inc */
+ /* Moved here from fparser.cc because fp_opcode_add.inc
+ * is also now included by fpoptimizer.cc
+ */
+ bool IsLogicalOpcode(unsigned op);
+ bool IsComparisonOpcode(unsigned op);
+ unsigned OppositeComparisonOpcode(unsigned op);
+ bool IsNeverNegativeValueOpcode(unsigned op);
+ bool IsAlwaysIntegerOpcode(unsigned op);
+ bool IsUnaryOpcode(unsigned op);
+ bool IsBinaryOpcode(unsigned op);
+ bool IsVarOpcode(unsigned op);
+ bool IsCommutativeOrParamSwappableBinaryOpcode(unsigned op);
+ unsigned GetParamSwappedBinaryOpcode(unsigned op);
+
+ template<bool ComplexType>
+ bool HasInvalidRangesOpcode(unsigned op);
+
+ template<typename Value_t>
+ inline Value_t DegreesToRadians(const Value_t& degrees)
+ {
+ return degrees * fp_const_deg_to_rad<Value_t>();
+ }
+
+ template<typename Value_t>
+ inline Value_t RadiansToDegrees(const Value_t& radians)
+ {
+ return radians * fp_const_rad_to_deg<Value_t>();
+ }
+
+ template<typename Value_t>
+ inline long makeLongInteger(const Value_t& value)
+ {
+ return (long) fp_int(value);
+ }
+
+#ifdef FP_SUPPORT_COMPLEX_NUMBERS
+ template<typename T>
+ inline long makeLongInteger(const std::complex<T>& value)
+ {
+ return (long) fp_int( std::abs(value) );
+ }
+#endif
+
+ // Is value an integer that fits in "long" datatype?
+ template<typename Value_t>
+ inline bool isLongInteger(const Value_t& value)
+ {
+ return value == Value_t( makeLongInteger(value) );
+ }
+
+ template<typename Value_t>
+ inline bool isOddInteger(const Value_t& value)
+ {
+ const Value_t halfValue = (value + Value_t(1)) * Value_t(0.5);
+ return fp_equal(halfValue, fp_floor(halfValue));
+ }
+
+ template<typename Value_t>
+ inline bool isEvenInteger(const Value_t& value)
+ {
+ const Value_t halfValue = value * Value_t(0.5);
+ return fp_equal(halfValue, fp_floor(halfValue));
+ }
+
+ template<typename Value_t>
+ inline bool isInteger(const Value_t& value)
+ {
+ return fp_equal(value, fp_floor(value));
+ }
+
+#ifdef FP_SUPPORT_LONG_INT_TYPE
+ template<>
+ inline bool isEvenInteger(const long& value)
+ {
+ return value%2 == 0;
+ }
+
+ template<>
+ inline bool isInteger(const long&) { return true; }
+
+ template<>
+ inline bool isLongInteger(const long&) { return true; }
+
+ template<>
+ inline long makeLongInteger(const long& value)
+ {
+ return value;
+ }
+#endif
+
+#ifdef FP_SUPPORT_MPFR_FLOAT_TYPE
+ template<>
+ inline bool isInteger(const MpfrFloat& value) { return value.isInteger(); }
+
+ template<>
+ inline bool isEvenInteger(const MpfrFloat& value)
+ {
+ return isInteger(value) && value%2 == 0;
+ }
+
+ template<>
+ inline long makeLongInteger(const MpfrFloat& value)
+ {
+ return (long) value.toInt();
+ }
+#endif
+
+#ifdef FP_SUPPORT_GMP_INT_TYPE
+ template<>
+ inline bool isEvenInteger(const GmpInt& value)
+ {
+ return value%2 == 0;
+ }
+
+ template<>
+ inline bool isInteger(const GmpInt&) { return true; }
+
+ template<>
+ inline long makeLongInteger(const GmpInt& value)
+ {
+ return (long) value.toInt();
+ }
+#endif
+
+#ifdef FP_SUPPORT_LONG_INT_TYPE
+ template<>
+ inline bool isOddInteger(const long& value)
+ {
+ return value%2 != 0;
+ }
+#endif
+
+#ifdef FP_SUPPORT_MPFR_FLOAT_TYPE
+ template<>
+ inline bool isOddInteger(const MpfrFloat& value)
+ {
+ return value.isInteger() && value%2 != 0;
+ }
+#endif
+
+#ifdef FP_SUPPORT_GMP_INT_TYPE
+ template<>
+ inline bool isOddInteger(const GmpInt& value)
+ {
+ return value%2 != 0;
+ }
+#endif
+
+
+// -------------------------------------------------------------------------
+// fp_pow
+// -------------------------------------------------------------------------
+ // Commented versions in fparser.cc
+ template<typename Value_t>
+ inline Value_t fp_pow_with_exp_log(const Value_t& x, const Value_t& y)
+ {
+ return fp_exp(fp_log(x) * y);
+ }
+
+ template<typename Value_t>
+ inline Value_t fp_powi(Value_t x, unsigned long y)
+ {
+ Value_t result(1);
+ while(y != 0)
+ {
+ if(y & 1) { result *= x; y -= 1; }
+ else { x *= x; y /= 2; }
+ }
+ return result;
+ }
+
+ template<typename Value_t>
+ Value_t fp_pow(const Value_t& x, const Value_t& y)
+ {
+ if(x == Value_t(1)) return Value_t(1);
+ if(isLongInteger(y))
+ {
+ if(y >= Value_t(0))
+ return fp_powi(x, makeLongInteger(y));
+ else
+ return Value_t(1) / fp_powi(x, -makeLongInteger(y));
+ }
+ if(y >= Value_t(0))
+ {
+ if(x > Value_t(0)) return fp_pow_with_exp_log(x, y);
+ if(x == Value_t(0)) return Value_t(0);
+ if(!isInteger(y*Value_t(16)))
+ return -fp_pow_with_exp_log(-x, y);
+ }
+ else
+ {
+ if(x > Value_t(0)) return fp_pow_with_exp_log(Value_t(1) / x, -y);
+ if(x < Value_t(0))
+ {
+ if(!isInteger(y*Value_t(-16)))
+ return -fp_pow_with_exp_log(Value_t(-1) / x, -y);
+ }
+ }
+ return fp_pow_base(x, y);
+ }
+
+ template<typename Value_t>
+ inline Value_t fp_exp2(const Value_t& x)
+ {
+ return fp_pow(Value_t(2), x);
+ }
+} // namespace FUNCTIONPARSERTYPES
+
+#endif // ONCE_FPARSER_H_
+#endif // ONCE_FPARSER_AUX_H_
diff --git a/extrasrc/fptypes.hh b/extrasrc/fptypes.hh
new file mode 100644
index 0000000..ea28cbc
--- /dev/null
+++ b/extrasrc/fptypes.hh
@@ -0,0 +1,286 @@
+/***************************************************************************\
+|* Function Parser for C++ v4.5.2 *|
+|*-------------------------------------------------------------------------*|
+|* Copyright: Juha Nieminen, 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 only internal types for the function parser library.
+// You don't need to include this file in your code. Include "fparser.hh"
+// only.
+
+#ifndef ONCE_FPARSER_TYPES_H_
+#define ONCE_FPARSER_TYPES_H_
+
+#include "../fpconfig.hh"
+#include <cstring>
+
+#ifdef ONCE_FPARSER_H_
+#include <map>
+#endif
+
+namespace FUNCTIONPARSERTYPES
+{
+ enum OPCODE
+ {
+// The order of opcodes in the function list must
+// match that which is in the Functions[] array.
+ cAbs,
+ cAcos, cAcosh,
+ cArg, /* get the phase angle of a complex value */
+ cAsin, cAsinh,
+ cAtan, cAtan2, cAtanh,
+ cCbrt, cCeil,
+ cConj, /* get the complex conjugate of a complex value */
+ cCos, cCosh, cCot, cCsc,
+ cExp, cExp2, cFloor, cHypot,
+ cIf,
+ cImag, /* get imaginary part of a complex value */
+ cInt, cLog, cLog10, cLog2, cMax, cMin,
+ cPolar, /* create a complex number from polar coordinates */
+ cPow,
+ cReal, /* get real part of a complex value */
+ cSec, cSin, cSinh, cSqrt, cTan, cTanh,
+ cTrunc,
+
+// These do not need any ordering:
+// Except that if you change the order of {eq,neq,lt,le,gt,ge}, you
+// must also change the order in ConstantFolding_ComparisonOperations().
+ cImmed, cJump,
+ cNeg, cAdd, cSub, cMul, cDiv, cMod,
+ cEqual, cNEqual, cLess, cLessOrEq, cGreater, cGreaterOrEq,
+ cNot, cAnd, cOr,
+ cNotNot, /* Protects the double-not sequence from optimizations */
+
+ cDeg, cRad, /* Multiplication and division by 180 / pi */
+
+ cFCall, cPCall,
+
+#ifdef FP_SUPPORT_OPTIMIZER
+ cPopNMov, /* cPopNMov(x,y) moves [y] to [x] and deletes anything
+ * above [x]. Used for disposing of temporaries.
+ */
+ cLog2by, /* log2by(x,y) = log2(x) * y */
+ cNop, /* Used by fpoptimizer internally; should not occur in bytecode */
+#endif
+ cSinCos, /* sin(x) followed by cos(x) (two values are pushed to stack) */
+ cSinhCosh, /* hyperbolic equivalent of sincos */
+ cAbsAnd, /* As cAnd, but assume both operands are absolute values */
+ cAbsOr, /* As cOr, but assume both operands are absolute values */
+ cAbsNot, /* As cAbsNot, but assume the operand is an absolute value */
+ cAbsNotNot, /* As cAbsNotNot, but assume the operand is an absolute value */
+ cAbsIf, /* As cAbsIf, but assume the 1st operand is an absolute value */
+
+ cDup, /* Duplicates the last value in the stack: Push [Stacktop] */
+ cFetch, /* Same as Dup, except with absolute index
+ * (next value is index) */
+ cInv, /* Inverts the last value in the stack (x = 1/x) */
+ cSqr, /* squares the last operand in the stack, no push/pop */
+ cRDiv, /* reverse division (not x/y, but y/x) */
+ cRSub, /* reverse subtraction (not x-y, but y-x) */
+ cRSqrt, /* inverse square-root (1/sqrt(x)) */
+
+ VarBegin
+ };
+
+#ifdef ONCE_FPARSER_H_
+ struct FuncDefinition
+ {
+ enum FunctionFlags
+ {
+ Enabled = 0x01,
+ AngleIn = 0x02,
+ AngleOut = 0x04,
+ OkForInt = 0x08,
+ ComplexOnly = 0x10
+ };
+
+#ifdef FUNCTIONPARSER_SUPPORT_DEBUGGING
+ const char name[8];
+#endif
+ unsigned params : 8;
+ unsigned flags : 8;
+
+ inline bool okForInt() const { return (flags & OkForInt) != 0; }
+ inline bool complexOnly() const { return (flags & ComplexOnly) != 0; }
+ };
+
+#ifdef FUNCTIONPARSER_SUPPORT_DEBUGGING
+# define FP_FNAME(n) n,
+#else
+# define FP_FNAME(n)
+#endif
+// This list must be in the same order as that in OPCODE enum,
+// because the opcode value is used to index this array, and
+// the pointer to array element is used for generating the opcode.
+ const FuncDefinition Functions[]=
+ {
+ /*cAbs */ { FP_FNAME("abs") 1, FuncDefinition::OkForInt },
+ /*cAcos */ { FP_FNAME("acos") 1, FuncDefinition::AngleOut },
+ /*cAcosh*/ { FP_FNAME("acosh") 1, FuncDefinition::AngleOut },
+ /*cArg */ { FP_FNAME("arg") 1, FuncDefinition::AngleOut | FuncDefinition::ComplexOnly },
+ /*cAsin */ { FP_FNAME("asin") 1, FuncDefinition::AngleOut },
+ /*cAsinh*/ { FP_FNAME("asinh") 1, FuncDefinition::AngleOut },
+ /*cAtan */ { FP_FNAME("atan") 1, FuncDefinition::AngleOut },
+ /*cAtan2*/ { FP_FNAME("atan2") 2, FuncDefinition::AngleOut },
+ /*cAtanh*/ { FP_FNAME("atanh") 1, 0 },
+ /*cCbrt */ { FP_FNAME("cbrt") 1, 0 },
+ /*cCeil */ { FP_FNAME("ceil") 1, 0 },
+ /*cConj */ { FP_FNAME("conj") 1, FuncDefinition::ComplexOnly },
+ /*cCos */ { FP_FNAME("cos") 1, FuncDefinition::AngleIn },
+ /*cCosh */ { FP_FNAME("cosh") 1, FuncDefinition::AngleIn },
+ /*cCot */ { FP_FNAME("cot") 1, FuncDefinition::AngleIn },
+ /*cCsc */ { FP_FNAME("csc") 1, FuncDefinition::AngleIn },
+ /*cExp */ { FP_FNAME("exp") 1, 0 },
+ /*cExp2 */ { FP_FNAME("exp2") 1, 0 },
+ /*cFloor*/ { FP_FNAME("floor") 1, 0 },
+ /*cHypot*/ { FP_FNAME("hypot") 2, 0 },
+ /*cIf */ { FP_FNAME("if") 0, FuncDefinition::OkForInt },
+ /*cImag */ { FP_FNAME("imag") 1, FuncDefinition::ComplexOnly },
+ /*cInt */ { FP_FNAME("int") 1, 0 },
+ /*cLog */ { FP_FNAME("log") 1, 0 },
+ /*cLog10*/ { FP_FNAME("log10") 1, 0 },
+ /*cLog2 */ { FP_FNAME("log2") 1, 0 },
+ /*cMax */ { FP_FNAME("max") 2, FuncDefinition::OkForInt },
+ /*cMin */ { FP_FNAME("min") 2, FuncDefinition::OkForInt },
+ /*cPolar */{ FP_FNAME("polar") 2, FuncDefinition::ComplexOnly | FuncDefinition::AngleIn },
+ /*cPow */ { FP_FNAME("pow") 2, 0 },
+ /*cReal */ { FP_FNAME("real") 1, FuncDefinition::ComplexOnly },
+ /*cSec */ { FP_FNAME("sec") 1, FuncDefinition::AngleIn },
+ /*cSin */ { FP_FNAME("sin") 1, FuncDefinition::AngleIn },
+ /*cSinh */ { FP_FNAME("sinh") 1, FuncDefinition::AngleIn },
+ /*cSqrt */ { FP_FNAME("sqrt") 1, 0 },
+ /*cTan */ { FP_FNAME("tan") 1, FuncDefinition::AngleIn },
+ /*cTanh */ { FP_FNAME("tanh") 1, FuncDefinition::AngleIn },
+ /*cTrunc*/ { FP_FNAME("trunc") 1, 0 }
+ };
+#undef FP_FNAME
+
+ struct NamePtr
+ {
+ const char* name;
+ unsigned nameLength;
+
+ NamePtr(const char* n, unsigned l): name(n), nameLength(l) {}
+
+ inline bool operator==(const NamePtr& rhs) const
+ {
+ return nameLength == rhs.nameLength
+ && std::memcmp(name, rhs.name, nameLength) == 0;
+ }
+ inline bool operator<(const NamePtr& rhs) const
+ {
+ for(unsigned i = 0; i < nameLength; ++i)
+ {
+ if(i == rhs.nameLength) return false;
+ const char c1 = name[i], c2 = rhs.name[i];
+ if(c1 < c2) return true;
+ if(c2 < c1) return false;
+ }
+ return nameLength < rhs.nameLength;
+ }
+ };
+
+ template<typename Value_t>
+ struct NameData
+ {
+ enum DataType { CONSTANT, UNIT, FUNC_PTR, PARSER_PTR, VARIABLE };
+ DataType type;
+ unsigned index;
+ Value_t value;
+
+ NameData(DataType t, unsigned v) : type(t), index(v), value() { }
+ NameData(DataType t, Value_t v) : type(t), index(), value(v) { }
+ NameData() { }
+ };
+
+ template<typename Value_t>
+ class NamePtrsMap: public
+ std::map<FUNCTIONPARSERTYPES::NamePtr,
+ FUNCTIONPARSERTYPES::NameData<Value_t> >
+ {
+ };
+
+ const unsigned FUNC_AMOUNT = sizeof(Functions)/sizeof(Functions[0]);
+#endif // ONCE_FPARSER_H_
+}
+
+#ifdef ONCE_FPARSER_H_
+#include <vector>
+
+template<typename Value_t>
+struct FunctionParserBase<Value_t>::Data
+{
+ unsigned mReferenceCounter;
+
+ char mDelimiterChar;
+ ParseErrorType mParseErrorType;
+ int mEvalErrorType;
+ bool mUseDegreeConversion;
+ bool mHasByteCodeFlags;
+ const char* mErrorLocation;
+
+ unsigned mVariablesAmount;
+ std::string mVariablesString;
+ FUNCTIONPARSERTYPES::NamePtrsMap<Value_t> mNamePtrs;
+
+ struct InlineVariable
+ {
+ FUNCTIONPARSERTYPES::NamePtr mName;
+ unsigned mFetchIndex;
+ };
+
+ typedef std::vector<InlineVariable> InlineVarNamesContainer;
+ InlineVarNamesContainer mInlineVarNames;
+
+ struct FuncWrapperPtrData
+ {
+ /* Only one of the pointers will point to a function, the other
+ will be null. (The raw function pointer could be implemented
+ as a FunctionWrapper specialization, but it's done like this
+ for efficiency.) */
+ FunctionPtr mRawFuncPtr;
+ FunctionWrapper* mFuncWrapperPtr;
+ unsigned mParams;
+
+ FuncWrapperPtrData();
+ ~FuncWrapperPtrData();
+ FuncWrapperPtrData(const FuncWrapperPtrData&);
+ FuncWrapperPtrData& operator=(const FuncWrapperPtrData&);
+ };
+
+ struct FuncParserPtrData
+ {
+ FunctionParserBase<Value_t>* mParserPtr;
+ unsigned mParams;
+ };
+
+ std::vector<FuncWrapperPtrData> mFuncPtrs;
+ std::vector<FuncParserPtrData> mFuncParsers;
+
+ std::vector<unsigned> mByteCode;
+ std::vector<Value_t> mImmed;
+
+#if !defined(FP_USE_THREAD_SAFE_EVAL) && \
+ !defined(FP_USE_THREAD_SAFE_EVAL_WITH_ALLOCA)
+ std::vector<Value_t> mStack;
+ // Note: When mStack exists,
+ // mStack.size() and mStackSize are mutually redundant.
+#endif
+
+ unsigned mStackSize;
+
+ Data();
+ Data(const Data&);
+ Data& operator=(const Data&); // not implemented on purpose
+ ~Data();
+};
+#endif
+
+//#include "fpaux.hh"
+
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-19 14:40:38 +0000