Numeric.SpecFunctions:logBeta from math-functions-0.1.5.2, B

Time bar (total: 13.0s)

analyze25.0ms (0.2%)

Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
0%0%99.6%0.4%0%0%0%0
0%0%99.6%0.4%0%0%0%1
0%0%99.6%0.4%0%0%0%2
0%0%49.8%0.4%0%49.8%0%3
0%0%49.8%0.4%0%49.8%0%4
0%0%49.8%0.4%0%49.8%0%5
0%0%49.8%0.4%0%49.8%0%6
0%0%49.8%0.4%0%49.8%0%7
100%24.9%0%0.4%0%74.7%0%8
Compiler

Compiled 30 to 21 computations (30% saved)

Precisions
Click to see histograms. Total time spent on operations: 14.0ms
ival-add: 6.0ms (42.8% of total)
ival-mult: 4.0ms (28.5% of total)
ival-log: 3.0ms (21.4% of total)
ival-sub: 1.0ms (7.1% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

sample2.0s (15.7%)

Results
1.6s8256×0valid
Precisions
Click to see histograms. Total time spent on operations: 1.1s
ival-add: 498.0ms (45.9% of total)
ival-mult: 264.0ms (24.3% of total)
ival-log: 258.0ms (23.8% of total)
ival-sub: 49.0ms (4.5% of total)
const: 12.0ms (1.1% of total)
backward-pass: 4.0ms (0.4% of total)
Bogosity

preprocess256.0ms (2%)

Algorithm
2×egg-herbie
Rules
9500×sum3-define
2336×+-lowering-+.f64
2336×+-lowering-+.f32
1972×fnmsub-define
1692×sum5-define
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
0245836
1879783
24277773
37702773
02018
14417
214617
393417
4346517
5402817
6413417
7413417
8413417
9413417
10413417
0818817
Stop Event
1×iter limit
1×node limit
1×node limit
Calls
Call 1
Inputs
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
Outputs
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 t (+.f64 a (*.f64 y i))))))
Call 2
Inputs
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* (neg x) (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* x (log (neg y))) z) t) a) (* (- b 1/2) (log c))) (* (neg y) i))
(+ (+ (+ (+ (+ (* x (log y)) (neg z)) t) a) (* (- b 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) (neg t)) a) (* (- b 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) t) (neg a)) (* (- b 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- (neg b) 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log (neg c)))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y (neg i)))
(neg (+ (+ (+ (+ (+ (* (neg x) (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)))
(neg (+ (+ (+ (+ (+ (* x (log (neg y))) z) t) a) (* (- b 1/2) (log c))) (* (neg y) i)))
(neg (+ (+ (+ (+ (+ (* x (log y)) (neg z)) t) a) (* (- b 1/2) (log c))) (* y i)))
(neg (+ (+ (+ (+ (+ (* x (log y)) z) (neg t)) a) (* (- b 1/2) (log c))) (* y i)))
(neg (+ (+ (+ (+ (+ (* x (log y)) z) t) (neg a)) (* (- b 1/2) (log c))) (* y i)))
(neg (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- (neg b) 1/2) (log c))) (* y i)))
(neg (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log (neg c)))) (* y i)))
(neg (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y (neg i))))
(+ (+ (+ (+ (+ (* y (log x)) z) t) a) (* (- b 1/2) (log c))) (* x i))
(+ (+ (+ (+ (+ (* z (log y)) x) t) a) (* (- b 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* t (log y)) z) x) a) (* (- b 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* a (log y)) z) t) x) (* (- b 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* b (log y)) z) t) a) (* (- x 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* c (log y)) z) t) a) (* (- b 1/2) (log x))) (* y i))
(+ (+ (+ (+ (+ (* i (log y)) z) t) a) (* (- b 1/2) (log c))) (* y x))
(+ (+ (+ (+ (+ (* x (log z)) y) t) a) (* (- b 1/2) (log c))) (* z i))
(+ (+ (+ (+ (+ (* x (log t)) z) y) a) (* (- b 1/2) (log c))) (* t i))
(+ (+ (+ (+ (+ (* x (log a)) z) t) y) (* (- b 1/2) (log c))) (* a i))
(+ (+ (+ (+ (+ (* x (log b)) z) t) a) (* (- y 1/2) (log c))) (* b i))
(+ (+ (+ (+ (+ (* x (log c)) z) t) a) (* (- b 1/2) (log y))) (* c i))
(+ (+ (+ (+ (+ (* x (log i)) z) t) a) (* (- b 1/2) (log c))) (* i y))
(+ (+ (+ (+ (+ (* x (log y)) t) z) a) (* (- b 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) a) t) z) (* (- b 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) b) t) a) (* (- z 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) c) t) a) (* (- b 1/2) (log z))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) i) t) a) (* (- b 1/2) (log c))) (* y z))
(+ (+ (+ (+ (+ (* x (log y)) z) a) t) (* (- b 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) b) a) (* (- t 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) c) a) (* (- b 1/2) (log t))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) i) a) (* (- b 1/2) (log c))) (* y t))
(+ (+ (+ (+ (+ (* x (log y)) z) t) b) (* (- a 1/2) (log c))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) t) c) (* (- b 1/2) (log a))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) t) i) (* (- b 1/2) (log c))) (* y a))
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- c 1/2) (log b))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- i 1/2) (log c))) (* y b))
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log i))) (* y c))
Outputs
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
(sum5 z (fma x (log y) t) a (* (+ b -1/2) (log c)) (* y i))
(+ (+ (+ (+ (+ (* (neg x) (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
(sum5 t (fnmadd x (log y) z) a (* (+ b -1/2) (log c)) (* y i))
(+ (+ (+ (+ (+ (* x (log (neg y))) z) t) a) (* (- b 1/2) (log c))) (* (neg y) i))
(sum5 z (* x (log (neg y))) t a (fmsub (+ b -1/2) (log c) (* y i)))
(+ (+ (+ (+ (+ (* x (log y)) (neg z)) t) a) (* (- b 1/2) (log c))) (* y i))
(sum5 t (fmsub x (log y) z) a (* (+ b -1/2) (log c)) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) (neg t)) a) (* (- b 1/2) (log c))) (* y i))
(sum5 (* x (log y)) z (neg t) a (fma (+ b -1/2) (log c) (* y i)))
(+ (+ (+ (+ (+ (* x (log y)) z) t) (neg a)) (* (- b 1/2) (log c))) (* y i))
(sum5 (* x (log y)) z t (neg a) (fma (+ b -1/2) (log c) (* y i)))
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- (neg b) 1/2) (log c))) (* y i))
(sum5 (fma x (log y) z) t a (* (log c) (- -1/2 b)) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log (neg c)))) (* y i))
(sum5 (fma x (log y) z) t a (* (+ b -1/2) (log (neg c))) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y (neg i)))
(sum5 (* x (log y)) z t a (fmsub (+ b -1/2) (log c) (* y i)))
(neg (+ (+ (+ (+ (+ (* (neg x) (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)))
(fnmsub y i (sum4 t (fnmadd x (log y) z) a (* (+ b -1/2) (log c))))
(neg (+ (+ (+ (+ (+ (* x (log (neg y))) z) t) a) (* (- b 1/2) (log c))) (* (neg y) i)))
(fmsub y i (sum4 t (fma x (log (neg y)) z) a (* (+ b -1/2) (log c))))
(neg (+ (+ (+ (+ (+ (* x (log y)) (neg z)) t) a) (* (- b 1/2) (log c))) (* y i)))
(fnmsub y i (sum4 t (fmsub x (log y) z) a (* (+ b -1/2) (log c))))
(neg (+ (+ (+ (+ (+ (* x (log y)) z) (neg t)) a) (* (- b 1/2) (log c))) (* y i)))
(fnmsub y i (sum5 (* x (log y)) z (neg t) a (* (+ b -1/2) (log c))))
(neg (+ (+ (+ (+ (+ (* x (log y)) z) t) (neg a)) (* (- b 1/2) (log c))) (* y i)))
(fnmsub y i (sum5 (* x (log y)) z t (neg a) (* (+ b -1/2) (log c))))
(neg (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- (neg b) 1/2) (log c))) (* y i)))
(fnmsub y i (sum5 (* x (log y)) z t a (* (log c) (- -1/2 b))))
(neg (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log (neg c)))) (* y i)))
(fnmsub y i (sum5 (* x (log y)) z t a (* (+ b -1/2) (log (neg c)))))
(neg (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y (neg i))))
(fmsub y i (sum5 (* x (log y)) z t a (* (+ b -1/2) (log c))))
(+ (+ (+ (+ (+ (* y (log x)) z) t) a) (* (- b 1/2) (log c))) (* x i))
(sum5 t (fma y (log x) z) a (* (+ b -1/2) (log c)) (* x i))
(+ (+ (+ (+ (+ (* z (log y)) x) t) a) (* (- b 1/2) (log c))) (* y i))
(sum5 t (fma (log y) z x) a (* (+ b -1/2) (log c)) (* y i))
(+ (+ (+ (+ (+ (* t (log y)) z) x) a) (* (- b 1/2) (log c))) (* y i))
(sum5 x (fma (log y) t z) a (* (+ b -1/2) (log c)) (* y i))
(+ (+ (+ (+ (+ (* a (log y)) z) t) x) (* (- b 1/2) (log c))) (* y i))
(sum5 z (* (log y) a) t x (fma (+ b -1/2) (log c) (* y i)))
(+ (+ (+ (+ (+ (* b (log y)) z) t) a) (* (- x 1/2) (log c))) (* y i))
(sum5 t (fma (log y) b z) a (* (log c) (+ x -1/2)) (* y i))
(+ (+ (+ (+ (+ (* c (log y)) z) t) a) (* (- b 1/2) (log x))) (* y i))
(sum5 z (* (log y) c) t a (fma (+ b -1/2) (log x) (* y i)))
(+ (+ (+ (+ (+ (* i (log y)) z) t) a) (* (- b 1/2) (log c))) (* y x))
(sum5 z (* (log y) i) t a (fma (+ b -1/2) (log c) (* x y)))
(+ (+ (+ (+ (+ (* x (log z)) y) t) a) (* (- b 1/2) (log c))) (* z i))
(sum5 y (* x (log z)) t a (fma (+ b -1/2) (log c) (* z i)))
(+ (+ (+ (+ (+ (* x (log t)) z) y) a) (* (- b 1/2) (log c))) (* t i))
(sum5 y (fma x (log t) z) a (* (+ b -1/2) (log c)) (* t i))
(+ (+ (+ (+ (+ (* x (log a)) z) t) y) (* (- b 1/2) (log c))) (* a i))
(sum5 z (* x (log a)) t y (fma (+ b -1/2) (log c) (* a i)))
(+ (+ (+ (+ (+ (* x (log b)) z) t) a) (* (- y 1/2) (log c))) (* b i))
(sum5 z (* x (log b)) t a (fma (log c) (+ y -1/2) (* b i)))
(+ (+ (+ (+ (+ (* x (log c)) z) t) a) (* (- b 1/2) (log y))) (* c i))
(sum5 z (* x (log c)) t a (fma (log y) (+ b -1/2) (* c i)))
(+ (+ (+ (+ (+ (* x (log i)) z) t) a) (* (- b 1/2) (log c))) (* i y))
(sum5 t (fma x (log i) z) a (* (+ b -1/2) (log c)) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) t) z) a) (* (- b 1/2) (log c))) (* y i))
(sum5 z (fma x (log y) t) a (* (+ b -1/2) (log c)) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) a) t) z) (* (- b 1/2) (log c))) (* y i))
(sum5 z (fma x (log y) t) a (* (+ b -1/2) (log c)) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) b) t) a) (* (- z 1/2) (log c))) (* y i))
(sum5 (* x (log y)) b t a (fma (log c) (+ z -1/2) (* y i)))
(+ (+ (+ (+ (+ (* x (log y)) c) t) a) (* (- b 1/2) (log z))) (* y i))
(sum5 t (fma x (log y) c) a (* (+ b -1/2) (log z)) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) i) t) a) (* (- b 1/2) (log c))) (* y z))
(sum5 t (fma x (log y) i) a (* (+ b -1/2) (log c)) (* y z))
(+ (+ (+ (+ (+ (* x (log y)) z) a) t) (* (- b 1/2) (log c))) (* y i))
(sum5 z (fma x (log y) t) a (* (+ b -1/2) (log c)) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) b) a) (* (- t 1/2) (log c))) (* y i))
(sum5 (fma x (log y) z) b a (* (log c) (+ t -1/2)) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) c) a) (* (- b 1/2) (log t))) (* y i))
(sum5 (fma x (log y) z) c a (* (+ b -1/2) (log t)) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) i) a) (* (- b 1/2) (log c))) (* y t))
(sum5 (fma x (log y) z) i a (* (+ b -1/2) (log c)) (* y t))
(+ (+ (+ (+ (+ (* x (log y)) z) t) b) (* (- a 1/2) (log c))) (* y i))
(sum5 (fma x (log y) z) t b (* (log c) (+ a -1/2)) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) t) c) (* (- b 1/2) (log a))) (* y i))
(sum5 (fma x (log y) z) t c (* (+ b -1/2) (log a)) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) t) i) (* (- b 1/2) (log c))) (* y a))
(sum5 (fma x (log y) z) t i (* (+ b -1/2) (log c)) (* y a))
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- c 1/2) (log b))) (* y i))
(sum5 (fma x (log y) z) t a (* (log b) (+ c -1/2)) (* y i))
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- i 1/2) (log c))) (* y b))
(sum5 (fma x (log y) z) t a (* (log c) (+ i -1/2)) (* y b))
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log i))) (* y c))
(sum5 (fma x (log y) z) t a (* (+ b -1/2) (log i)) (* y c))
Symmetry

(sort z t a)

explain258.0ms (2%)

FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
00-0-x
00-0-b
00-0-(+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
00-0-(-.f64 b #s(literal 1/2 binary64))
00-0-(*.f64 y i)
00-0-z
00-0-(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
00-0-(*.f64 x (log.f64 y))
00-0-(log.f64 c)
00-0-#s(literal 1/2 binary64)
00-0-(+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t)
00-0-y
00-0-i
00-0-(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
00-0-(+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)
00-0-c
00-0-t
00-0-a
00-0-(+.f64 (*.f64 x (log.f64 y)) z)
00-0-(log.f64 y)
Results
181.0ms512×0valid
Compiler

Compiled 229 to 62 computations (72.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 82.0ms
ival-sub: 34.0ms (41.3% of total)
ival-add: 18.0ms (21.8% of total)
ival-log: 14.0ms (17% of total)
ival-mult: 12.0ms (14.6% of total)
const: 4.0ms (4.9% of total)
backward-pass: 0.0ms (0% of total)

eval0.0ms (0%)

Compiler

Compiled 29 to 20 computations (31% saved)

prune1.0ms (0%)

Alt Table
Click to see full alt table
StatusAccuracyProgram
▶99.9%
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Compiler

Compiled 29 to 20 computations (31% saved)

simplify183.0ms (1.4%)

Algorithm
1×egg-herbie
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t)
✓cost-diff0
(+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)
✓cost-diff0
(+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
✓cost-diff0
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Rules
9500×sum3-define
2336×+-lowering-+.f64
2336×+-lowering-+.f32
1692×sum5-define
1112×associate-+r+
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
02082
14480
214680
393480
4346580
5402880
6413480
7413480
8413480
9413480
10413480
0818880
Stop Event
1×iter limit
1×node limit
Calls
Call 1
Inputs
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
(+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))
(+ (+ (+ (* x (log y)) z) t) a)
(+ (+ (* x (log y)) z) t)
(+ (* x (log y)) z)
(* x (log y))
x
(log y)
y
z
t
a
(* (- b 1/2) (log c))
(- b 1/2)
b
1/2
(log c)
c
(* y i)
i
Outputs
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 t (+.f64 a (*.f64 y i))))))
(+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 t a))))
(+ (+ (+ (* x (log y)) z) t) a)
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t (+.f64 z a)))
(+ (+ (* x (log y)) z) t)
(+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))
(+ (* x (log y)) z)
(+.f64 (*.f64 x (log.f64 y)) z)
(* x (log y))
(*.f64 x (log.f64 y))
x
(log y)
(log.f64 y)
y
z
t
a
(* (- b 1/2) (log c))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))
(- b 1/2)
(+.f64 b #s(literal -1/2 binary64))
b
1/2
#s(literal 1/2 binary64)
(log c)
(log.f64 c)
c
(* y i)
(*.f64 y i)
i

localize116.0ms (0.9%)

Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
✓accuracy100.0%
(+.f64 (*.f64 x (log.f64 y)) z)
✓accuracy99.8%
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
✓accuracy99.6%
(*.f64 x (log.f64 y))
Results
77.0ms256×0valid
Compiler

Compiled 100 to 21 computations (79% saved)

Precisions
Click to see histograms. Total time spent on operations: 21.0ms
ival-log: 7.0ms (33.6% of total)
ival-add: 6.0ms (28.8% of total)
ival-mult: 6.0ms (28.8% of total)
ival-sub: 1.0ms (4.8% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

series191.0ms (1.5%)

Counts
7 → 372
Calls
Call 1
Inputs
#<alt (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))>
#<alt (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))>
#<alt (+ (+ (+ (* x (log y)) z) t) a)>
#<alt (+ (+ (* x (log y)) z) t)>
#<alt (* x (log y))>
#<alt (* (- b 1/2) (log c))>
#<alt (+ (* x (log y)) z)>
Outputs
#<alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (* x (log y))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))>
#<alt (* x (log y))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (* i y)>
#<alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))>
#<alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))>
#<alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))>
#<alt (* i y)>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))>
#<alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt z>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))>
#<alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt t>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))>
#<alt t>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))>
#<alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt a>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (* i y)>
#<alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))>
#<alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))>
#<alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))>
#<alt (* i y)>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (* x (log y))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))>
#<alt (* x (log y))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt z>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))>
#<alt (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt t>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))>
#<alt t>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))>
#<alt (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt a>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))>
#<alt (+ a (+ t z))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (* x (log y))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))>
#<alt (* x (log y))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))>
#<alt (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))>
#<alt (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))>
#<alt (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))>
#<alt (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))>
#<alt (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))>
#<alt (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))>
#<alt (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))>
#<alt (+ a (+ t (* x (log y))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt z>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))>
#<alt (+ a (+ z (* x (log y))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt t>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))>
#<alt t>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt a>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))>
#<alt (+ t z)>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (* x (log y))>
#<alt (* x (+ (log y) (+ (/ t x) (/ z x))))>
#<alt (* x (+ (log y) (+ (/ t x) (/ z x))))>
#<alt (* x (+ (log y) (+ (/ t x) (/ z x))))>
#<alt (* x (log y))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* -1 (* x (log (/ 1 y))))))>
#<alt (+ t (+ z (* -1 (* x (log (/ 1 y))))))>
#<alt (+ t (+ z (* -1 (* x (log (/ 1 y))))))>
#<alt (+ t (+ z (* -1 (* x (log (/ 1 y))))))>
#<alt (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))>
#<alt (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))>
#<alt (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))>
#<alt (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))>
#<alt (+ t (* x (log y)))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt z>
#<alt (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))>
#<alt (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))>
#<alt (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))>
#<alt (+ z (* x (log y)))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt t>
#<alt (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))>
#<alt (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))>
#<alt (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))>
#<alt t>
#<alt (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* -1 (* x (log (/ 1 y))))>
#<alt (* -1 (* x (log (/ 1 y))))>
#<alt (* -1 (* x (log (/ 1 y))))>
#<alt (* -1 (* x (log (/ 1 y))))>
#<alt (* x (+ (log -1) (* -1 (log (/ -1 y)))))>
#<alt (* x (+ (log -1) (* -1 (log (/ -1 y)))))>
#<alt (* x (+ (log -1) (* -1 (log (/ -1 y)))))>
#<alt (* x (+ (log -1) (* -1 (log (/ -1 y)))))>
#<alt (* -1/2 (log c))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt z>
#<alt (+ z (* x (log y)))>
#<alt (+ z (* x (log y)))>
#<alt (+ z (* x (log y)))>
#<alt (* x (log y))>
#<alt (* x (+ (log y) (/ z x)))>
#<alt (* x (+ (log y) (/ z x)))>
#<alt (* x (+ (log y) (/ z x)))>
#<alt (* x (log y))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))>
#<alt (+ z (* x (log y)))>
#<alt (+ z (* x (log y)))>
#<alt (+ z (* x (log y)))>
#<alt (+ z (* x (log y)))>
#<alt (+ z (* -1 (* x (log (/ 1 y)))))>
#<alt (+ z (* -1 (* x (log (/ 1 y)))))>
#<alt (+ z (* -1 (* x (log (/ 1 y)))))>
#<alt (+ z (* -1 (* x (log (/ 1 y)))))>
#<alt (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))>
#<alt (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))>
#<alt (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))>
#<alt (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))>
#<alt (* x (log y))>
#<alt (+ z (* x (log y)))>
#<alt (+ z (* x (log y)))>
#<alt (+ z (* x (log y)))>
#<alt z>
#<alt (* z (+ 1 (/ (* x (log y)) z)))>
#<alt (* z (+ 1 (/ (* x (log y)) z)))>
#<alt (* z (+ 1 (/ (* x (log y)) z)))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))>
Calls

93 calls:

TimeVariablePointExpression
39.0ms
c
@0
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
34.0ms
y
@0
(+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))
18.0ms
c
@-inf
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
14.0ms
z
@0
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
14.0ms
x
@0
(* x (log y))

rewrite430.0ms (3.3%)

Algorithm
1×batch-egg-rewrite
Rules
3924×*-lowering-*.f32
3924×*-lowering-*.f64
2352×/-lowering-/.f32
2352×/-lowering-/.f64
2034×+-lowering-+.f64
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
02063
111961
2128161
0830761
Stop Event
1×iter limit
1×node limit
Counts
7 → 362
Calls
Call 1
Inputs
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
(+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))
(+ (+ (+ (* x (log y)) z) t) a)
(+ (+ (* x (log y)) z) t)
(* x (log y))
(* (- b 1/2) (log c))
(+ (* x (log y)) z)
Outputs
(+.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 (+.f64 t a) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) (+.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) (+.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i)))
(+.f64 a (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 y i)))
(+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (*.f64 y i) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))))
(+.f64 (+.f64 (*.f64 y i) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 (+.f64 (*.f64 y i) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a)))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(-.f64 (/.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(fma.f64 y i (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 y i)))
(fma.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 y i)))
(fma.f64 i y (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 3 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))))))) (*.f64 y i))
(fma.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))) (+.f64 (+.f64 t a) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(fma.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))) (+.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(fma.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))) (+.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i)))
(fma.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(fma.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 y i))
(fma.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 x (log.f64 y)) z)) (+.f64 (+.f64 t a) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(fma.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))) (+.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(fma.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))) (+.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i)))
(fma.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i)))))
(/.f64 (-.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (neg.f64 (+.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))) (neg.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 3 binary64)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (-.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))))
(/.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64))) (-.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))) (-.f64 (*.f64 y i) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 (+.f64 t a) (*.f64 (+.f64 t a) (+.f64 t a)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 (+.f64 t a) (*.f64 (+.f64 t a) (+.f64 t a)))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (+.f64 t a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (+.f64 t a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 (+.f64 t a) (*.f64 (+.f64 t a) (+.f64 t a)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (+.f64 t a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 (+.f64 t a) (*.f64 (+.f64 t a) (+.f64 t a)))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (+.f64 t a))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))
(/.f64 (-.f64 (*.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (*.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))) (*.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(pow.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (-.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(*.f64 (-.f64 (pow.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (+.f64 z t) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 (+.f64 t a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 t (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 a (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))))
(+.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))
(+.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (*.f64 x (log.f64 y)) z)) (+.f64 t a))
(+.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) a)
(-.f64 (/.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (-.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (/.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(fma.f64 x (log.f64 y) (+.f64 (+.f64 z t) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(fma.f64 (log.f64 y) x (+.f64 (+.f64 z t) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))))
(fma.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))))
(fma.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))) (+.f64 t (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(fma.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))) (+.f64 (+.f64 t a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(fma.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 x (log.f64 y)) z)) (+.f64 t (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(fma.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 x (log.f64 y)) z)) (+.f64 (+.f64 t a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 3 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a)))))))
(/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 3 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (-.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 3 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a)))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 3 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))) (-.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) t))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) t))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) t))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) t))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 (+.f64 z t) (*.f64 (+.f64 z t) (+.f64 z t)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 z t) (+.f64 z t)) (*.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 z t) (+.f64 z t)) (*.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 (+.f64 z t) (*.f64 (+.f64 z t) (+.f64 z t)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 z t) (+.f64 z t)) (*.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 z t) (+.f64 z t)) (*.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t)))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t)))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (+.f64 z t) (+.f64 z t))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (-.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (+.f64 z t) (+.f64 z t))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (-.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (-.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 t t) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 t t) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 (+.f64 t a) (*.f64 (+.f64 t a) (+.f64 t a)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 (+.f64 t a) (*.f64 (+.f64 t a) (+.f64 t a)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 (+.f64 t a) (*.f64 (+.f64 t a) (+.f64 t a)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 (+.f64 t a) (*.f64 (+.f64 t a) (+.f64 t a)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (+.f64 t a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (+.f64 t a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (+.f64 t a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (+.f64 t a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 (+.f64 t a) (*.f64 (+.f64 t a) (+.f64 t a)))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (+.f64 t a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 (+.f64 t a) (*.f64 (+.f64 t a) (+.f64 t a)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (+.f64 t a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 (+.f64 t a) (*.f64 (+.f64 t a) (+.f64 t a)))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (+.f64 t a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 (+.f64 t a) (*.f64 (+.f64 t a) (+.f64 t a)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (+.f64 t a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (+.f64 (*.f64 t t) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) t)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (+.f64 (*.f64 t t) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) t)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t)))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 z t) (+.f64 z t)) (*.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 (+.f64 z t) (*.f64 (+.f64 z t) (+.f64 z t)))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 z t) (+.f64 z t)) (*.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (-.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (+.f64 z t) (+.f64 z t))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (-.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (-.f64 (*.f64 t t) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (+.f64 (*.f64 t t) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) t)))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (+.f64 (*.f64 t t) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) t)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t)))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 z t) (+.f64 z t)) (*.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 (+.f64 z t) (*.f64 (+.f64 z t) (+.f64 z t)))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 z t) (+.f64 z t)) (*.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 1 binary64))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 1 binary64))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (-.f64 (*.f64 x (log.f64 y)) (+.f64 z t))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (+.f64 z t) (+.f64 z t))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 t t) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))
(/.f64 (-.f64 (*.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (-.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (pow.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)))
(pow.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a)))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 3 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 3 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))))))))
(*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 z (+.f64 t a)))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (+.f64 z t) a))
(+.f64 z (+.f64 (*.f64 x (log.f64 y)) (+.f64 t a)))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a))
(+.f64 t (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) a))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a)
(+.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))
(+.f64 (+.f64 t a) (+.f64 (*.f64 x (log.f64 y)) z))
(+.f64 (+.f64 a (*.f64 x (log.f64 y))) (+.f64 z t))
(+.f64 (+.f64 a (+.f64 (*.f64 x (log.f64 y)) z)) t)
(-.f64 (/.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (/.f64 (*.f64 a a) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))))
(fma.f64 x (log.f64 y) (+.f64 z (+.f64 t a)))
(fma.f64 x (log.f64 y) (+.f64 (+.f64 z t) a))
(fma.f64 (log.f64 y) x (+.f64 z (+.f64 t a)))
(fma.f64 (log.f64 y) x (+.f64 (+.f64 z t) a))
(fma.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))) (+.f64 t a))
(fma.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))) a)
(fma.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 x (log.f64 y)) z)) (+.f64 t a))
(fma.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))) a)
(/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))))
(/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) a))))
(/.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)))
(/.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))))
(/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 (+.f64 t a) (*.f64 (+.f64 t a) (+.f64 t a)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))))
(/.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (+.f64 t a))) (-.f64 (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 t a)))
(/.f64 (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64))) (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))) (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))) (-.f64 t a)) (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (-.f64 (*.f64 t t) (*.f64 a a)))) (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (-.f64 t a)))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) z))) (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) z))) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))) (-.f64 t a)) (*.f64 (+.f64 (*.f64 z z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) z))) (-.f64 (*.f64 t t) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) z))) (-.f64 t a)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))) (*.f64 (-.f64 (*.f64 x (log.f64 y)) z) (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (*.f64 x (log.f64 y)) z) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)) (-.f64 t a)) (*.f64 (-.f64 (*.f64 x (log.f64 y)) z) (-.f64 (*.f64 t t) (*.f64 a a)))) (*.f64 (-.f64 (*.f64 x (log.f64 y)) z) (-.f64 t a)))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z)))) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))) (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z)))) (-.f64 t a)) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))) (-.f64 (*.f64 t t) (*.f64 a a)))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))) (-.f64 t a)))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z))) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))) (*.f64 (neg.f64 (-.f64 (*.f64 x (log.f64 y)) z)) (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))))) (*.f64 (neg.f64 (-.f64 (*.f64 x (log.f64 y)) z)) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z))) (-.f64 t a)) (*.f64 (neg.f64 (-.f64 (*.f64 x (log.f64 y)) z)) (-.f64 (*.f64 t t) (*.f64 a a)))) (*.f64 (neg.f64 (-.f64 (*.f64 x (log.f64 y)) z)) (-.f64 t a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z)))) (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z)))) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 t a)) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z)))) (-.f64 (*.f64 t t) (*.f64 a a)))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z)))) (-.f64 t a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))) (*.f64 (/.f64 (-.f64 (*.f64 x (log.f64 y)) z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z))) (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))))) (*.f64 (/.f64 (-.f64 (*.f64 x (log.f64 y)) z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z))) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 t a)) (*.f64 (/.f64 (-.f64 (*.f64 x (log.f64 y)) z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z))) (-.f64 (*.f64 t t) (*.f64 a a)))) (*.f64 (/.f64 (-.f64 (*.f64 x (log.f64 y)) z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z))) (-.f64 t a)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))) (*.f64 (-.f64 z (*.f64 x (log.f64 y))) (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 z (*.f64 x (log.f64 y))) (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (-.f64 t a)) (*.f64 (-.f64 z (*.f64 x (log.f64 y))) (-.f64 (*.f64 t t) (*.f64 a a)))) (*.f64 (-.f64 z (*.f64 x (log.f64 y))) (-.f64 t a)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 z z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) z)))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (+.f64 (*.f64 z z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))) (-.f64 (*.f64 x (log.f64 y)) z)) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (-.f64 (*.f64 x (log.f64 y)) z)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))) (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z)))))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))) (neg.f64 (-.f64 (*.f64 x (log.f64 y)) z))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (neg.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z))))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (neg.f64 (-.f64 (*.f64 x (log.f64 y)) z))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))) (/.f64 (-.f64 (*.f64 x (log.f64 y)) z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (/.f64 (-.f64 (*.f64 x (log.f64 y)) z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 t (*.f64 t t)) (*.f64 a (*.f64 a a))) (-.f64 z (*.f64 x (log.f64 y)))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (-.f64 (*.f64 z z) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 t t) (-.f64 (*.f64 a a) (*.f64 t a))) (-.f64 z (*.f64 x (log.f64 y)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 t t) (*.f64 a a)) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))) (*.f64 (-.f64 t a) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))))) (*.f64 (-.f64 t a) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 t t) (*.f64 a a)) (+.f64 (*.f64 z z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) z)))) (*.f64 (-.f64 t a) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))))) (*.f64 (-.f64 t a) (+.f64 (*.f64 z z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 t t) (*.f64 a a)) (-.f64 (*.f64 x (log.f64 y)) z)) (*.f64 (-.f64 t a) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)))) (*.f64 (-.f64 t a) (-.f64 (*.f64 x (log.f64 y)) z)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 t t) (*.f64 a a)) (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))))) (*.f64 (-.f64 t a) (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z)))))) (*.f64 (-.f64 t a) (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 t t) (*.f64 a a)) (neg.f64 (-.f64 (*.f64 x (log.f64 y)) z))) (*.f64 (-.f64 t a) (neg.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z))))) (*.f64 (-.f64 t a) (neg.f64 (-.f64 (*.f64 x (log.f64 y)) z))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 t t) (*.f64 a a)) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))))) (*.f64 (-.f64 t a) #s(literal 1 binary64))) (*.f64 (-.f64 t a) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 t t) (*.f64 a a)) (/.f64 (-.f64 (*.f64 x (log.f64 y)) z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)))) (*.f64 (-.f64 t a) #s(literal 1 binary64))) (*.f64 (-.f64 t a) (/.f64 (-.f64 (*.f64 x (log.f64 y)) z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 t t) (*.f64 a a)) (-.f64 z (*.f64 x (log.f64 y)))) (*.f64 (-.f64 t a) (-.f64 (*.f64 z z) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))))) (*.f64 (-.f64 t a) (-.f64 z (*.f64 x (log.f64 y)))))
(/.f64 (-.f64 (*.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (*.f64 a a))) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) #s(literal 2 binary64)))
(pow.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))))
(*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (+.f64 z t) a))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 z t))
(+.f64 z (+.f64 (*.f64 x (log.f64 y)) t))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t)
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) z))
(+.f64 (+.f64 z t) (*.f64 x (log.f64 y)))
(+.f64 (+.f64 t (*.f64 x (log.f64 y))) z)
(-.f64 (/.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))) (/.f64 (*.f64 t t) (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))))
(fma.f64 x (log.f64 y) (+.f64 z t))
(fma.f64 (log.f64 y) x (+.f64 z t))
(fma.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))) t)
(fma.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 x (log.f64 y)) z)) t)
(/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))))
(/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))) (+.f64 (*.f64 t t) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) z) t))))
(/.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)) (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)))
(/.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))))
(/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 (+.f64 z t) (*.f64 (+.f64 z t) (+.f64 z t)))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 z t) (+.f64 z t)) (*.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t))))
(/.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (+.f64 z t) (+.f64 z t))) (-.f64 (*.f64 x (log.f64 y)) (+.f64 z t)))
(/.f64 (-.f64 (*.f64 t t) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64))) (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))
(/.f64 (-.f64 (*.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (*.f64 t t))) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) #s(literal 2 binary64)))
(pow.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z)))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t)) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 3 binary64)) (*.f64 t (*.f64 t t))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t (-.f64 t (+.f64 (*.f64 x (log.f64 y)) z))))))
(*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x (log.f64 y)) (-.f64 z t))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 y) x)
(+.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(+.f64 (*.f64 b (log.f64 c)) (*.f64 #s(literal -1/2 binary64) (log.f64 c)))
(fma.f64 b (log.f64 c) (*.f64 #s(literal -1/2 binary64) (log.f64 c)))
(fma.f64 (log.f64 c) b (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(/.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 b #s(literal 1/2 binary64)))
(/.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 b #s(literal 1/2 binary64)))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 x (log.f64 y)) z)
(+.f64 z (*.f64 x (log.f64 y)))
(-.f64 (/.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (*.f64 x (log.f64 y)) z)) (/.f64 (*.f64 z z) (-.f64 (*.f64 x (log.f64 y)) z)))
(fma.f64 x (log.f64 y) z)
(fma.f64 (log.f64 y) x z)
(/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))))
(/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) z))))
(/.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)) (-.f64 (*.f64 x (log.f64 y)) z))
(/.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z)))) (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z))) (neg.f64 (-.f64 (*.f64 x (log.f64 y)) z)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 x (log.f64 y)) z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z))))
(/.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (-.f64 z (*.f64 x (log.f64 y))))
(/.f64 (-.f64 (*.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (*.f64 x (log.f64 y)) z)) (*.f64 (-.f64 (*.f64 x (log.f64 y)) z) (*.f64 z z))) (pow.f64 (-.f64 (*.f64 x (log.f64 y)) z) #s(literal 2 binary64)))
(pow.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y))))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (*.f64 x (log.f64 y)) z) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z (-.f64 z (*.f64 x (log.f64 y)))))))
(*.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 x (log.f64 y)) z)))

simplify294.0ms (2.3%)

Algorithm
1×egg-herbie
Rules
4152×+-lowering-+.f64
4152×+-lowering-+.f32
3802×*-lowering-*.f32
3802×*-lowering-*.f64
1208×--lowering--.f32
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
03615274
112114717
252164597
081114597
Stop Event
1×iter limit
1×node limit
Counts
372 → 372
Calls
Call 1
Inputs
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t z))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+ a (+ t (* x (log y))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(+ a (+ z (* x (log y))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(+ t (+ z (* x (log y))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(+ t z)
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(* x (log y))
(* x (+ (log y) (+ (/ t x) (/ z x))))
(* x (+ (log y) (+ (/ t x) (/ z x))))
(* x (+ (log y) (+ (/ t x) (/ z x))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+ t (* x (log y)))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
z
(* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))
(* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))
(* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))
z
(* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))
(+ z (* x (log y)))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
t
(* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))
(* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))
(* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))
t
(* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* -1/2 (log c))
(+ (* -1/2 (log c)) (* b (log c)))
(+ (* -1/2 (log c)) (* b (log c)))
(+ (* -1/2 (log c)) (* b (log c)))
(* b (log c))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
z
(+ z (* x (log y)))
(+ z (* x (log y)))
(+ z (* x (log y)))
(* x (log y))
(* x (+ (log y) (/ z x)))
(* x (+ (log y) (/ z x)))
(* x (+ (log y) (/ z x)))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))
(+ z (* x (log y)))
(+ z (* x (log y)))
(+ z (* x (log y)))
(+ z (* x (log y)))
(+ z (* -1 (* x (log (/ 1 y)))))
(+ z (* -1 (* x (log (/ 1 y)))))
(+ z (* -1 (* x (log (/ 1 y)))))
(+ z (* -1 (* x (log (/ 1 y)))))
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(* x (log y))
(+ z (* x (log y)))
(+ z (* x (log y)))
(+ z (* x (log y)))
z
(* z (+ 1 (/ (* x (log y)) z)))
(* z (+ 1 (/ (* x (log y)) z)))
(* z (+ 1 (/ (* x (log y)) z)))
z
(* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))
(* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))
(* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))
Outputs
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 t (+.f64 (*.f64 i y) (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (/.f64 t x) (+.f64 (/.f64 z x) (+.f64 (/.f64 (*.f64 i y) x) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (/.f64 t x) (+.f64 (/.f64 z x) (+.f64 (/.f64 (*.f64 i y) x) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (/.f64 t x) (+.f64 (/.f64 z x) (+.f64 (/.f64 (*.f64 i y) x) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x)))))))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (+.f64 a (+.f64 t (+.f64 (*.f64 i y) (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))) x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (+.f64 a (+.f64 t (+.f64 (*.f64 i y) (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))) x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (+.f64 a (+.f64 t (+.f64 (*.f64 i y) (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 y (+.f64 i (+.f64 (*.f64 (log.f64 y) (/.f64 x y)) (+.f64 (+.f64 (/.f64 z y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) (+.f64 (/.f64 a y) (/.f64 t y))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 y (+.f64 i (+.f64 (*.f64 (log.f64 y) (/.f64 x y)) (+.f64 (+.f64 (/.f64 z y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) (+.f64 (/.f64 a y) (/.f64 t y))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 y (+.f64 i (+.f64 (*.f64 (log.f64 y) (/.f64 x y)) (+.f64 (+.f64 (/.f64 z y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) (+.f64 (/.f64 a y) (/.f64 t y))))))
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 y (+.f64 i (/.f64 (+.f64 a (+.f64 (+.f64 t (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))) y)))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 y (+.f64 i (/.f64 (+.f64 a (+.f64 (+.f64 t (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))) y)))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 y (+.f64 i (/.f64 (+.f64 a (+.f64 (+.f64 t (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))) y)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (+.f64 (/.f64 t z) (*.f64 x (/.f64 (log.f64 y) z))) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) z) (/.f64 a z))) (/.f64 (*.f64 i y) z))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (+.f64 (/.f64 t z) (*.f64 x (/.f64 (log.f64 y) z))) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) z) (/.f64 a z))) (/.f64 (*.f64 i y) z))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (+.f64 (/.f64 t z) (*.f64 x (/.f64 (log.f64 y) z))) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) z) (/.f64 a z))) (/.f64 (*.f64 i y) z))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+.f64 (*.f64 z (/.f64 (+.f64 (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (+.f64 a t)) z)) z)
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+.f64 (*.f64 z (/.f64 (+.f64 (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (+.f64 a t)) z)) z)
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+.f64 (*.f64 z (/.f64 (+.f64 (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (+.f64 a t)) z)) z)
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(*.f64 t (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a t)) (+.f64 (/.f64 z t) (/.f64 (*.f64 i y) t))) (+.f64 (*.f64 x (/.f64 (log.f64 y) t)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) t))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(*.f64 t (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a t)) (+.f64 (/.f64 z t) (/.f64 (*.f64 i y) t))) (+.f64 (*.f64 x (/.f64 (log.f64 y) t)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) t))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(*.f64 t (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a t)) (+.f64 (/.f64 z t) (/.f64 (*.f64 i y) t))) (+.f64 (*.f64 x (/.f64 (log.f64 y) t)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) t))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+.f64 (*.f64 t (/.f64 (+.f64 a (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) t)) t)
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+.f64 (*.f64 t (/.f64 (+.f64 a (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) t)) t)
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+.f64 (*.f64 t (/.f64 (+.f64 a (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) t)) t)
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 t (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 t a) (+.f64 (+.f64 (*.f64 x (/.f64 (log.f64 y) a)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) a))) (+.f64 (/.f64 z a) (/.f64 (*.f64 i y) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 t a) (+.f64 (+.f64 (*.f64 x (/.f64 (log.f64 y) a)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) a))) (+.f64 (/.f64 z a) (/.f64 (*.f64 i y) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 t a) (+.f64 (+.f64 (*.f64 x (/.f64 (log.f64 y) a)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) a))) (+.f64 (/.f64 z a) (/.f64 (*.f64 i y) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+.f64 (*.f64 a (/.f64 (+.f64 t (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) a)) a)
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+.f64 (*.f64 a (/.f64 (+.f64 t (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) a)) a)
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+.f64 (*.f64 a (/.f64 (+.f64 t (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) a)) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 i y) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 b (+.f64 (+.f64 (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)) (+.f64 (/.f64 a b) (/.f64 t b))) (+.f64 (/.f64 z b) (+.f64 (/.f64 (*.f64 i y) b) (*.f64 x (/.f64 (log.f64 y) b))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 b (+.f64 (+.f64 (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)) (+.f64 (/.f64 a b) (/.f64 t b))) (+.f64 (/.f64 z b) (+.f64 (/.f64 (*.f64 i y) b) (*.f64 x (/.f64 (log.f64 y) b))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 b (+.f64 (+.f64 (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)) (+.f64 (/.f64 a b) (/.f64 t b))) (+.f64 (/.f64 z b) (+.f64 (/.f64 (*.f64 i y) b) (*.f64 x (/.f64 (log.f64 y) b))))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (+.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 i y) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) b)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (+.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 i y) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) b)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (+.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 i y) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) b)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 a t) (+.f64 z (*.f64 i y))) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 a t) (+.f64 z (*.f64 i y))) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 a t) (+.f64 z (*.f64 i y))) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 a t) (+.f64 z (*.f64 i y))) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 a t))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 i (+.f64 y (+.f64 (+.f64 (*.f64 x (/.f64 (log.f64 y) i)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) i)) (/.f64 z i))) (+.f64 (/.f64 a i) (/.f64 t i)))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 i (+.f64 y (+.f64 (+.f64 (*.f64 x (/.f64 (log.f64 y) i)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) i)) (/.f64 z i))) (+.f64 (/.f64 a i) (/.f64 t i)))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 i (+.f64 y (+.f64 (+.f64 (*.f64 x (/.f64 (log.f64 y) i)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) i)) (/.f64 z i))) (+.f64 (/.f64 a i) (/.f64 t i)))))
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 i (+.f64 y (/.f64 (+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 i (+.f64 y (/.f64 (+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 i (+.f64 y (/.f64 (+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) i)))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x) (+.f64 (/.f64 t x) (/.f64 z x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x) (+.f64 (/.f64 t x) (/.f64 z x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x) (+.f64 (/.f64 t x) (/.f64 z x))))))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 (+.f64 t (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 (+.f64 t (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 (+.f64 t (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 (+.f64 t (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a t)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(*.f64 z (+.f64 (+.f64 (+.f64 (/.f64 a z) (/.f64 t z)) (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z)))) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) z)))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(*.f64 z (+.f64 (+.f64 (+.f64 (/.f64 a z) (/.f64 t z)) (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z)))) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) z)))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(*.f64 z (+.f64 (+.f64 (+.f64 (/.f64 a z) (/.f64 t z)) (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z)))) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) z)))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(+.f64 (*.f64 z (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a t)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) z)) z)
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(+.f64 (*.f64 z (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a t)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) z)) z)
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(+.f64 (*.f64 z (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a t)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) z)) z)
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(*.f64 t (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 a t) (+.f64 (/.f64 z t) (+.f64 (*.f64 x (/.f64 (log.f64 y) t)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(*.f64 t (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 a t) (+.f64 (/.f64 z t) (+.f64 (*.f64 x (/.f64 (log.f64 y) t)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(*.f64 t (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 a t) (+.f64 (/.f64 z t) (+.f64 (*.f64 x (/.f64 (log.f64 y) t)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(+.f64 (*.f64 t (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) t)) t)
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(+.f64 (*.f64 t (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) t)) t)
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(+.f64 (*.f64 t (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) t)) t)
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 z (+.f64 t (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (*.f64 x (/.f64 (log.f64 y) a)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) a))) (+.f64 (/.f64 t a) (/.f64 z a)))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (*.f64 x (/.f64 (log.f64 y) a)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) a))) (+.f64 (/.f64 t a) (/.f64 z a)))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (*.f64 x (/.f64 (log.f64 y) a)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) a))) (+.f64 (/.f64 t a) (/.f64 z a)))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(+.f64 (*.f64 a (/.f64 (+.f64 z (+.f64 t (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) a)) a)
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(+.f64 (*.f64 a (/.f64 (+.f64 z (+.f64 t (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) a)) a)
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(+.f64 (*.f64 a (/.f64 (+.f64 z (+.f64 t (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) a)) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (+.f64 (/.f64 t b) (+.f64 (/.f64 z b) (*.f64 x (/.f64 (log.f64 y) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (+.f64 (/.f64 t b) (+.f64 (/.f64 z b) (*.f64 x (/.f64 (log.f64 y) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (+.f64 (/.f64 t b) (+.f64 (/.f64 z b) (*.f64 x (/.f64 (log.f64 y) b))))))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (+.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (+.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (+.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t z))
(+.f64 a (+.f64 t z))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 z x) (+.f64 (/.f64 a x) (/.f64 t x)))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 z x) (+.f64 (/.f64 a x) (/.f64 t x)))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 z x) (+.f64 (/.f64 a x) (/.f64 t x)))))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (+.f64 a (+.f64 t z)) x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (+.f64 a (+.f64 t z)) x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (+.f64 a (+.f64 t z)) x)))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+.f64 (+.f64 a (+.f64 t z)) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+.f64 (+.f64 a (+.f64 t z)) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+.f64 (+.f64 a (+.f64 t z)) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+.f64 (+.f64 a (+.f64 t z)) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))
(+ a (+ t (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 a t))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(*.f64 z (+.f64 (+.f64 (/.f64 a z) (/.f64 t z)) (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(*.f64 z (+.f64 (+.f64 (/.f64 a z) (/.f64 t z)) (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(*.f64 z (+.f64 (+.f64 (/.f64 a z) (/.f64 t z)) (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z)))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(+.f64 (*.f64 z (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a t)) z)) z)
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(+.f64 (*.f64 z (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a t)) z)) z)
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(+.f64 (*.f64 z (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a t)) z)) z)
(+ a (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 a z))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(*.f64 t (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a t)) (/.f64 z t)) (*.f64 x (/.f64 (log.f64 y) t))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(*.f64 t (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a t)) (/.f64 z t)) (*.f64 x (/.f64 (log.f64 y) t))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(*.f64 t (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a t)) (/.f64 z t)) (*.f64 x (/.f64 (log.f64 y) t))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(+.f64 (*.f64 t (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)) t)) t)
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(+.f64 (*.f64 t (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)) t)) t)
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(+.f64 (*.f64 t (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)) t)) t)
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 t (+.f64 (*.f64 x (log.f64 y)) (+.f64 a z)))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(*.f64 a (+.f64 (+.f64 (/.f64 z a) (*.f64 x (/.f64 (log.f64 y) a))) (+.f64 #s(literal 1 binary64) (/.f64 t a))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(*.f64 a (+.f64 (+.f64 (/.f64 z a) (*.f64 x (/.f64 (log.f64 y) a))) (+.f64 #s(literal 1 binary64) (/.f64 t a))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(*.f64 a (+.f64 (+.f64 (/.f64 z a) (*.f64 x (/.f64 (log.f64 y) a))) (+.f64 #s(literal 1 binary64) (/.f64 t a))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(+.f64 (*.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a)) a)
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(+.f64 (*.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a)) a)
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(+.f64 (*.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a)) a)
(+ t z)
(+.f64 t z)
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (+ (log y) (+ (/ t x) (/ z x))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 t x) (/.f64 z x))))
(* x (+ (log y) (+ (/ t x) (/ z x))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 t x) (/.f64 z x))))
(* x (+ (log y) (+ (/ t x) (/ z x))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 t x) (/.f64 z x))))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (+.f64 t z) x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (+.f64 t z) x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (+.f64 t z) x)))
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+.f64 (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))) (+.f64 t z))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+.f64 (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))) (+.f64 t z))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+.f64 (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))) (+.f64 t z))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+.f64 (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))) (+.f64 t z))
(+ t (* x (log y)))
(+.f64 t (*.f64 x (log.f64 y)))
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
z
(* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))
(*.f64 z (+.f64 (/.f64 t z) (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z)))))
(* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))
(*.f64 z (+.f64 (/.f64 t z) (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z)))))
(* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))
(*.f64 z (+.f64 (/.f64 t z) (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z)))))
z
(* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))
(+.f64 (*.f64 z (/.f64 (+.f64 t (*.f64 x (log.f64 y))) z)) z)
(* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))
(+.f64 (*.f64 z (/.f64 (+.f64 t (*.f64 x (log.f64 y))) z)) z)
(* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))
(+.f64 (*.f64 z (/.f64 (+.f64 t (*.f64 x (log.f64 y))) z)) z)
(+ z (* x (log y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(+ t (+ z (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
t
(* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))
(*.f64 t (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 z t) (*.f64 x (/.f64 (log.f64 y) t)))))
(* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))
(*.f64 t (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 z t) (*.f64 x (/.f64 (log.f64 y) t)))))
(* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))
(*.f64 t (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 z t) (*.f64 x (/.f64 (log.f64 y) t)))))
t
(* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))
(+.f64 (*.f64 t (/.f64 (+.f64 z (*.f64 x (log.f64 y))) t)) t)
(* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))
(+.f64 (*.f64 t (/.f64 (+.f64 z (*.f64 x (log.f64 y))) t)) t)
(* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))
(+.f64 (*.f64 t (/.f64 (+.f64 z (*.f64 x (log.f64 y))) t)) t)
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (log (/ 1 y))))
(*.f64 x (log.f64 y))
(* -1 (* x (log (/ 1 y))))
(*.f64 x (log.f64 y))
(* -1 (* x (log (/ 1 y))))
(*.f64 x (log.f64 y))
(* -1 (* x (log (/ 1 y))))
(*.f64 x (log.f64 y))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))
(* -1/2 (log c))
(*.f64 (log.f64 c) #s(literal -1/2 binary64))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
z
(+ z (* x (log y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+ z (* x (log y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+ z (* x (log y)))
(+.f64 z (*.f64 x (log.f64 y)))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (+ (log y) (/ z x)))
(*.f64 x (+.f64 (log.f64 y) (/.f64 z x)))
(* x (+ (log y) (/ z x)))
(*.f64 x (+.f64 (log.f64 y) (/.f64 z x)))
(* x (+ (log y) (/ z x)))
(*.f64 x (+.f64 (log.f64 y) (/.f64 z x)))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 z x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 z x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))
(*.f64 x (+.f64 (log.f64 y) (/.f64 z x)))
(+ z (* x (log y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+ z (* x (log y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+ z (* x (log y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+ z (* x (log y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+ z (* -1 (* x (log (/ 1 y)))))
(+.f64 z (*.f64 x (log.f64 y)))
(+ z (* -1 (* x (log (/ 1 y)))))
(+.f64 z (*.f64 x (log.f64 y)))
(+ z (* -1 (* x (log (/ 1 y)))))
(+.f64 z (*.f64 x (log.f64 y)))
(+ z (* -1 (* x (log (/ 1 y)))))
(+.f64 z (*.f64 x (log.f64 y)))
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))
(* x (log y))
(*.f64 x (log.f64 y))
(+ z (* x (log y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+ z (* x (log y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+ z (* x (log y)))
(+.f64 z (*.f64 x (log.f64 y)))
z
(* z (+ 1 (/ (* x (log y)) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z))))
(* z (+ 1 (/ (* x (log y)) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z))))
(* z (+ 1 (/ (* x (log y)) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z))))
z
(* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))
(*.f64 z (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z))))
(* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))
(*.f64 z (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z))))
(* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))
(*.f64 z (+.f64 #s(literal 1 binary64) (*.f64 x (/.f64 (log.f64 y) z))))

eval142.0ms (1.1%)

Compiler

Compiled 32212 to 2106 computations (93.5% saved)

prune114.0ms (0.9%)

Pruning

19 alts after pruning (19 fresh and 0 done)

PrunedKeptTotal
New71519734
Fresh000
Picked101
Done000
Total71619735
Accuracy
100.0%
Counts
735 → 19
Alt Table
Click to see full alt table
StatusAccuracyProgram
81.2%
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (/.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 b #s(literal 1/2 binary64)))) (*.f64 y i))
▶83.1%
(+.f64 (+.f64 (+.f64 (*.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a)) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
82.5%
(+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
61.0%
(+.f64 (+.f64 (+.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
76.5%
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
▶56.4%
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
61.5%
(+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
▶60.3%
(+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
41.9%
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
79.9%
(+.f64 (*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (*.f64 x (/.f64 (log.f64 y) a)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) a))) (+.f64 (/.f64 t a) (/.f64 z a))))) (*.f64 y i))
▶47.2%
(+.f64 z (*.f64 y i))
45.6%
(+.f64 a (*.f64 y i))
14.6%
(*.f64 (log.f64 c) b)
67.8%
(*.f64 y (+.f64 i (+.f64 (*.f64 (log.f64 y) (/.f64 x y)) (+.f64 (+.f64 (/.f64 z y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) (+.f64 (/.f64 a y) (/.f64 t y))))))
18.4%
(*.f64 x (log.f64 y))
68.0%
(*.f64 i (+.f64 y (/.f64 (+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) i)))
25.8%
(*.f64 i y)
23.7%
z
▶21.8%
a
Compiler

Compiled 808 to 584 computations (27.7% saved)

simplify219.0ms (1.7%)

Algorithm
1×egg-herbie
Localize:

Found 14 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(log.f64 y)
✓cost-diff0
(*.f64 x (log.f64 y))
✓cost-diff0
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
✓cost-diff0
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
✓cost-diff0
(-.f64 b #s(literal 1/2 binary64))
✓cost-diff0
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
✓cost-diff0
(+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
✓cost-diff0
(+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
✓cost-diff0
(*.f64 y i)
✓cost-diff0
(+.f64 z (*.f64 y i))
✓cost-diff256
(*.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a))
✓cost-diff256
(+.f64 (*.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a)) a)
✓cost-diff256
(+.f64 (+.f64 (*.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a)) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
✓cost-diff256
(+.f64 (+.f64 (+.f64 (*.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a)) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Rules
4396×+-lowering-+.f64
4396×+-lowering-+.f32
4376×sum3-define
2756×associate-+r+
2298×*-lowering-*.f32
Iterations

Useful iterations: 5 (0.0ms)

IterNodesCost
027217
160211
2160211
3462201
4880194
51601191
62514191
72840191
84009191
95281191
105579191
115813191
09027191
Stop Event
1×iter limit
1×node limit
Calls
Call 1
Inputs
(+ (+ (+ (* a (/ (+ (* x (log y)) (+ t z)) a)) a) (* (- b 1/2) (log c))) (* y i))
(+ (+ (* a (/ (+ (* x (log y)) (+ t z)) a)) a) (* (- b 1/2) (log c)))
(+ (* a (/ (+ (* x (log y)) (+ t z)) a)) a)
(* a (/ (+ (* x (log y)) (+ t z)) a))
a
(/ (+ (* x (log y)) (+ t z)) a)
(+ (* x (log y)) (+ t z))
(* x (log y))
x
(log y)
y
(+ t z)
t
z
(* (- b 1/2) (log c))
(- b 1/2)
b
1/2
(log c)
c
(* y i)
i
a
(+ z (* y i))
z
(* y i)
y
i
(+ (+ a (* (- b 1/2) (log c))) (* y i))
(+ a (* (- b 1/2) (log c)))
a
(* (- b 1/2) (log c))
(- b 1/2)
b
1/2
(log c)
c
(* y i)
y
i
(+ (+ (* x (log y)) (* (- b 1/2) (log c))) (* y i))
(+ (* x (log y)) (* (- b 1/2) (log c)))
(* x (log y))
x
(log y)
y
(* (- b 1/2) (log c))
(- b 1/2)
b
1/2
(log c)
c
(* y i)
i
Outputs
(+ (+ (+ (* a (/ (+ (* x (log y)) (+ t z)) a)) a) (* (- b 1/2) (log c))) (* y i))
(+.f64 a (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(+ (+ (* a (/ (+ (* x (log y)) (+ t z)) a)) a) (* (- b 1/2) (log c)))
(+.f64 a (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+ (* a (/ (+ (* x (log y)) (+ t z)) a)) a)
(+.f64 (*.f64 x (log.f64 y)) (+.f64 a (+.f64 t z)))
(* a (/ (+ (* x (log y)) (+ t z)) a))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
a
(/ (+ (* x (log y)) (+ t z)) a)
(/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a)
(+ (* x (log y)) (+ t z))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))
(* x (log y))
(*.f64 x (log.f64 y))
x
(log y)
(log.f64 y)
y
(+ t z)
(+.f64 t z)
t
z
(* (- b 1/2) (log c))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))
(- b 1/2)
(+.f64 b #s(literal -1/2 binary64))
b
1/2
#s(literal 1/2 binary64)
(log c)
(log.f64 c)
c
(* y i)
(*.f64 y i)
i
a
(+ z (* y i))
(+.f64 z (*.f64 y i))
z
(* y i)
(*.f64 y i)
y
i
(+ (+ a (* (- b 1/2) (log c))) (* y i))
(+.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(+ a (* (- b 1/2) (log c)))
(+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
a
(* (- b 1/2) (log c))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))
(- b 1/2)
(+.f64 b #s(literal -1/2 binary64))
b
1/2
#s(literal 1/2 binary64)
(log c)
(log.f64 c)
c
(* y i)
(*.f64 y i)
y
i
(+ (+ (* x (log y)) (* (- b 1/2) (log c))) (* y i))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(+ (* x (log y)) (* (- b 1/2) (log c)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(* x (log y))
(*.f64 x (log.f64 y))
x
(log y)
(log.f64 y)
y
(* (- b 1/2) (log c))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))
(- b 1/2)
(+.f64 b #s(literal -1/2 binary64))
b
1/2
#s(literal 1/2 binary64)
(log c)
(log.f64 c)
c
(* y i)
(*.f64 y i)
i

localize247.0ms (1.9%)

Localize:

Found 14 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
✓accuracy100.0%
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
✓accuracy99.8%
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
✓accuracy99.6%
(*.f64 x (log.f64 y))
✓accuracy100.0%
(log.f64 c)
✓accuracy100.0%
(+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
✓accuracy100.0%
(+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
✓accuracy99.8%
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
✓accuracy100.0%
(*.f64 y i)
✓accuracy100.0%
(+.f64 z (*.f64 y i))
✓accuracy99.8%
(/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a)
✓accuracy99.8%
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
✓accuracy99.6%
(*.f64 x (log.f64 y))
✓accuracy78.9%
(*.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a))
Results
203.0ms256×0valid
Compiler

Compiled 235 to 28 computations (88.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 40.0ms
ival-add: 16.0ms (39.5% of total)
ival-mult: 13.0ms (32.1% of total)
ival-log: 8.0ms (19.8% of total)
ival-div: 2.0ms (4.9% of total)
ival-sub: 1.0ms (2.5% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

series34.0ms (0.3%)

Counts
16 → 708
Calls
Call 1
Inputs
#<alt (+ (+ (+ (* a (/ (+ (* x (log y)) (+ t z)) a)) a) (* (- b 1/2) (log c))) (* y i))>
#<alt (+ (+ (* a (/ (+ (* x (log y)) (+ t z)) a)) a) (* (- b 1/2) (log c)))>
#<alt (+ (* a (/ (+ (* x (log y)) (+ t z)) a)) a)>
#<alt (* a (/ (+ (* x (log y)) (+ t z)) a))>
#<alt (+ z (* y i))>
#<alt (* y i)>
#<alt (+ (+ a (* (- b 1/2) (log c))) (* y i))>
#<alt (+ a (* (- b 1/2) (log c)))>
#<alt (* (- b 1/2) (log c))>
#<alt (- b 1/2)>
#<alt (+ (+ (* x (log y)) (* (- b 1/2) (log c))) (* y i))>
#<alt (+ (* x (log y)) (* (- b 1/2) (log c)))>
#<alt (* x (log y))>
#<alt (log y)>
#<alt (/ (+ (* x (log y)) (+ t z)) a)>
#<alt (log c)>
Outputs
#<alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt a>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))>
#<alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (* x (log y))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))>
#<alt (* x (log y))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (* i y)>
#<alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))>
#<alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))>
#<alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))>
#<alt (* i y)>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))>
#<alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt t>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))>
#<alt t>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))>
#<alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt z>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))>
#<alt (* i y)>
#<alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))>
#<alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))>
#<alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))>
#<alt (* i y)>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))>
#<alt (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt a>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (* x (log y))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))>
#<alt (* x (log y))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt t>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))>
#<alt t>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))>
#<alt (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt z>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt a>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))>
#<alt (+ a (+ t z))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (* x (log y))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))>
#<alt (* x (log y))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))>
#<alt (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))>
#<alt (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))>
#<alt (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))>
#<alt (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))>
#<alt (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))>
#<alt (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))>
#<alt (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))>
#<alt (+ a (+ z (* x (log y))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt t>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))>
#<alt t>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))>
#<alt (+ a (+ t (* x (log y))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt (+ a (+ t (+ z (* x (log y)))))>
#<alt z>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t z)>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (* x (log y))>
#<alt (* x (+ (log y) (+ (/ t x) (/ z x))))>
#<alt (* x (+ (log y) (+ (/ t x) (/ z x))))>
#<alt (* x (+ (log y) (+ (/ t x) (/ z x))))>
#<alt (* x (log y))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* -1 (* x (log (/ 1 y))))))>
#<alt (+ t (+ z (* -1 (* x (log (/ 1 y))))))>
#<alt (+ t (+ z (* -1 (* x (log (/ 1 y))))))>
#<alt (+ t (+ z (* -1 (* x (log (/ 1 y))))))>
#<alt (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))>
#<alt (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))>
#<alt (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))>
#<alt (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))>
#<alt (+ z (* x (log y)))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt t>
#<alt (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))>
#<alt (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))>
#<alt (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))>
#<alt t>
#<alt (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))>
#<alt (+ t (* x (log y)))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt (+ t (+ z (* x (log y))))>
#<alt z>
#<alt (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))>
#<alt (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))>
#<alt (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))>
#<alt (* i y)>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt z>
#<alt (* z (+ 1 (/ (* i y) z)))>
#<alt (* z (+ 1 (/ (* i y) z)))>
#<alt (* z (+ 1 (/ (* i y) z)))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (* i y) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (* i y) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (* i y) z)) 1)))>
#<alt z>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt (* i y)>
#<alt (* y (+ i (/ z y)))>
#<alt (* y (+ i (/ z y)))>
#<alt (* y (+ i (/ z y)))>
#<alt (* i y)>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))>
#<alt z>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt (* i y)>
#<alt (* i (+ y (/ z i)))>
#<alt (* i (+ y (/ z i)))>
#<alt (* i (+ y (/ z i)))>
#<alt (* i y)>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (+ (* i y) (* (log c) (- b 1/2)))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt a>
#<alt (* a (+ 1 (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))>
#<alt (* a (+ 1 (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))>
#<alt (* a (+ 1 (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) a)) 1)))>
#<alt (+ a (+ (* -1/2 (log c)) (* i y)))>
#<alt (+ a (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))>
#<alt (+ a (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))>
#<alt (+ a (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ (* i y) b)))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ (* i y) b)))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ (* i y) b)))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ (* -1/2 (log c)) (* i y))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ (* -1/2 (log c)) (* i y))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ (* -1/2 (log c)) (* i y))) b)))))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))>
#<alt (+ a (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))>
#<alt (+ a (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))>
#<alt (+ a (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))>
#<alt (+ a (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ a (* (log c) (- b 1/2)))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (* i y)>
#<alt (* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* i y)>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (* (log c) (- b 1/2))) y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (* (log c) (- b 1/2))) y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (* (log c) (- b 1/2))) y)))))>
#<alt (+ a (* (log c) (- b 1/2)))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (* i y)>
#<alt (* i (+ y (+ (/ a i) (/ (* (log c) (- b 1/2)) i))))>
#<alt (* i (+ y (+ (/ a i) (/ (* (log c) (- b 1/2)) i))))>
#<alt (* i (+ y (+ (/ a i) (/ (* (log c) (- b 1/2)) i))))>
#<alt (* i y)>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (* (log c) (- b 1/2))) i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (* (log c) (- b 1/2))) i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (* (log c) (- b 1/2))) i)))))>
#<alt (* (log c) (- b 1/2))>
#<alt (+ a (* (log c) (- b 1/2)))>
#<alt (+ a (* (log c) (- b 1/2)))>
#<alt (+ a (* (log c) (- b 1/2)))>
#<alt a>
#<alt (* a (+ 1 (/ (* (log c) (- b 1/2)) a)))>
#<alt (* a (+ 1 (/ (* (log c) (- b 1/2)) a)))>
#<alt (* a (+ 1 (/ (* (log c) (- b 1/2)) a)))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (* (log c) (- b 1/2)) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (* (log c) (- b 1/2)) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (* (log c) (- b 1/2)) a)) 1)))>
#<alt (+ a (* -1/2 (log c)))>
#<alt (+ a (+ (* -1/2 (log c)) (* b (log c))))>
#<alt (+ a (+ (* -1/2 (log c)) (* b (log c))))>
#<alt (+ a (+ (* -1/2 (log c)) (* b (log c))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ a b))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ a b))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ a b))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* -1/2 (log c))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* -1/2 (log c))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* -1/2 (log c))) b)))))>
#<alt (+ a (* (log c) (- b 1/2)))>
#<alt (+ a (* (log c) (- b 1/2)))>
#<alt (+ a (* (log c) (- b 1/2)))>
#<alt (+ a (* (log c) (- b 1/2)))>
#<alt (+ a (* -1 (* (log (/ 1 c)) (- b 1/2))))>
#<alt (+ a (* -1 (* (log (/ 1 c)) (- b 1/2))))>
#<alt (+ a (* -1 (* (log (/ 1 c)) (- b 1/2))))>
#<alt (+ a (* -1 (* (log (/ 1 c)) (- b 1/2))))>
#<alt (+ a (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))>
#<alt (+ a (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))>
#<alt (+ a (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))>
#<alt (+ a (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))>
#<alt (* -1/2 (log c))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt -1/2>
#<alt (- b 1/2)>
#<alt (- b 1/2)>
#<alt (- b 1/2)>
#<alt b>
#<alt (* b (- 1 (* 1/2 (/ 1 b))))>
#<alt (* b (- 1 (* 1/2 (/ 1 b))))>
#<alt (* b (- 1 (* 1/2 (/ 1 b))))>
#<alt b>
#<alt (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))>
#<alt (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))>
#<alt (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))>
#<alt (+ (* i y) (* (log c) (- b 1/2)))>
#<alt (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))>
#<alt (* x (log y))>
#<alt (* x (+ (log y) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))>
#<alt (* x (+ (log y) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))>
#<alt (* x (+ (log y) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))>
#<alt (* x (log y))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) x)))))>
#<alt (+ (* x (log y)) (* (log c) (- b 1/2)))>
#<alt (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))>
#<alt (* i y)>
#<alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* i y)>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))) y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))) y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))) y)))))>
#<alt (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))>
#<alt (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))>
#<alt (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))>
#<alt (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ (* i y) b) (/ (* x (log y)) b)))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ (* i y) b) (/ (* x (log y)) b)))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ (* i y) b) (/ (* x (log y)) b)))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))) b)))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))>
#<alt (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))>
#<alt (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))>
#<alt (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))>
#<alt (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ (* x (log y)) (* (log c) (- b 1/2)))>
#<alt (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))>
#<alt (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))>
#<alt (* i y)>
#<alt (* i (+ y (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))>
#<alt (* i (+ y (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))>
#<alt (* i (+ y (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))>
#<alt (* i y)>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) i)))))>
#<alt (* (log c) (- b 1/2))>
#<alt (+ (* x (log y)) (* (log c) (- b 1/2)))>
#<alt (+ (* x (log y)) (* (log c) (- b 1/2)))>
#<alt (+ (* x (log y)) (* (log c) (- b 1/2)))>
#<alt (* x (log y))>
#<alt (* x (+ (log y) (/ (* (log c) (- b 1/2)) x)))>
#<alt (* x (+ (log y) (/ (* (log c) (- b 1/2)) x)))>
#<alt (* x (+ (log y) (/ (* (log c) (- b 1/2)) x)))>
#<alt (* x (log y))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* (log c) (- b 1/2)) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* (log c) (- b 1/2)) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* (log c) (- b 1/2)) x)))))>
#<alt (+ (* x (log y)) (* (log c) (- b 1/2)))>
#<alt (+ (* x (log y)) (* (log c) (- b 1/2)))>
#<alt (+ (* x (log y)) (* (log c) (- b 1/2)))>
#<alt (+ (* x (log y)) (* (log c) (- b 1/2)))>
#<alt (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))>
#<alt (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))>
#<alt (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))>
#<alt (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))>
#<alt (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))>
#<alt (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))>
#<alt (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))>
#<alt (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))>
#<alt (+ (* -1/2 (log c)) (* x (log y)))>
#<alt (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))>
#<alt (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))>
#<alt (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ (* x (log y)) b))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ (* x (log y)) b))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ (* x (log y)) b))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (* x (log y))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (* x (log y))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (* x (log y))) b)))))>
#<alt (+ (* x (log y)) (* (log c) (- b 1/2)))>
#<alt (+ (* x (log y)) (* (log c) (- b 1/2)))>
#<alt (+ (* x (log y)) (* (log c) (- b 1/2)))>
#<alt (+ (* x (log y)) (* (log c) (- b 1/2)))>
#<alt (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))>
#<alt (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))>
#<alt (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))>
#<alt (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))>
#<alt (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))>
#<alt (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))>
#<alt (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))>
#<alt (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* -1 (* x (log (/ 1 y))))>
#<alt (* -1 (* x (log (/ 1 y))))>
#<alt (* -1 (* x (log (/ 1 y))))>
#<alt (* -1 (* x (log (/ 1 y))))>
#<alt (* x (+ (log -1) (* -1 (log (/ -1 y)))))>
#<alt (* x (+ (log -1) (* -1 (log (/ -1 y)))))>
#<alt (* x (+ (log -1) (* -1 (log (/ -1 y)))))>
#<alt (* x (+ (log -1) (* -1 (log (/ -1 y)))))>
#<alt (log y)>
#<alt (log y)>
#<alt (log y)>
#<alt (log y)>
#<alt (* -1 (log (/ 1 y)))>
#<alt (* -1 (log (/ 1 y)))>
#<alt (* -1 (log (/ 1 y)))>
#<alt (* -1 (log (/ 1 y)))>
#<alt (+ (log -1) (* -1 (log (/ -1 y))))>
#<alt (+ (log -1) (* -1 (log (/ -1 y))))>
#<alt (+ (log -1) (* -1 (log (/ -1 y))))>
#<alt (+ (log -1) (* -1 (log (/ -1 y))))>
#<alt (/ (+ t z) a)>
#<alt (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))>
#<alt (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))>
#<alt (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))>
#<alt (/ (* x (log y)) a)>
#<alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (log y) a))))>
#<alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (log y) a))))>
#<alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (log y) a))))>
#<alt (/ (* x (log y)) a)>
#<alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (/ z a)) x)))))>
#<alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (/ z a)) x)))))>
#<alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (/ z a)) x)))))>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* -1 (* x (log (/ 1 y)))))) a)>
#<alt (/ (+ t (+ z (* -1 (* x (log (/ 1 y)))))) a)>
#<alt (/ (+ t (+ z (* -1 (* x (log (/ 1 y)))))) a)>
#<alt (/ (+ t (+ z (* -1 (* x (log (/ 1 y)))))) a)>
#<alt (/ (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))) a)>
#<alt (/ (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))) a)>
#<alt (/ (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))) a)>
#<alt (/ (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))) a)>
#<alt (/ (+ z (* x (log y))) a)>
#<alt (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))>
#<alt (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))>
#<alt (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))>
#<alt (/ t a)>
#<alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* x (log y)) (* a t)))))>
#<alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* x (log y)) (* a t)))))>
#<alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* x (log y)) (* a t)))))>
#<alt (/ t a)>
#<alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* x (log y)) a)) t)) (/ 1 a))))>
#<alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* x (log y)) a)) t)) (/ 1 a))))>
#<alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* x (log y)) a)) t)) (/ 1 a))))>
#<alt (/ (+ t (* x (log y))) a)>
#<alt (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))>
#<alt (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))>
#<alt (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))>
#<alt (/ z a)>
#<alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* x (log y)) (* a z)))))>
#<alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* x (log y)) (* a z)))))>
#<alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* x (log y)) (* a z)))))>
#<alt (/ z a)>
#<alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* x (log y)) a)) z)) (/ 1 a))))>
#<alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* x (log y)) a)) z)) (/ 1 a))))>
#<alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* x (log y)) a)) z)) (/ 1 a))))>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (/ (+ t (+ z (* x (log y)))) a)>
#<alt (log c)>
#<alt (log c)>
#<alt (log c)>
#<alt (log c)>
#<alt (* -1 (log (/ 1 c)))>
#<alt (* -1 (log (/ 1 c)))>
#<alt (* -1 (log (/ 1 c)))>
#<alt (* -1 (log (/ 1 c)))>
#<alt (+ (log -1) (* -1 (log (/ -1 c))))>
#<alt (+ (log -1) (* -1 (log (/ -1 c))))>
#<alt (+ (log -1) (* -1 (log (/ -1 c))))>
#<alt (+ (log -1) (* -1 (log (/ -1 c))))>
Calls

177 calls:

TimeVariablePointExpression
5.0ms
a
@0
(* a (/ (+ (* x (log y)) (+ t z)) a))
3.0ms
a
@inf
(/ (+ (* x (log y)) (+ t z)) a)
2.0ms
b
@-inf
(+ (* x (log y)) (* (- b 1/2) (log c)))
0.0ms
y
@-inf
(/ (+ (* x (log y)) (+ t z)) a)
0.0ms
y
@0
(/ (+ (* x (log y)) (+ t z)) a)

rewrite458.0ms (3.5%)

Algorithm
1×batch-egg-rewrite
Rules
4248×*-lowering-*.f32
4248×*-lowering-*.f64
3246×fma-lowering-fma.f32
3246×fma-lowering-fma.f64
3166×+-lowering-+.f64
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
027141
1187135
22016127
010135127
Stop Event
1×iter limit
1×node limit
Counts
16 → 574
Calls
Call 1
Inputs
(+ (+ (+ (* a (/ (+ (* x (log y)) (+ t z)) a)) a) (* (- b 1/2) (log c))) (* y i))
(+ (+ (* a (/ (+ (* x (log y)) (+ t z)) a)) a) (* (- b 1/2) (log c)))
(+ (* a (/ (+ (* x (log y)) (+ t z)) a)) a)
(* a (/ (+ (* x (log y)) (+ t z)) a))
(+ z (* y i))
(* y i)
(+ (+ a (* (- b 1/2) (log c))) (* y i))
(+ a (* (- b 1/2) (log c)))
(* (- b 1/2) (log c))
(- b 1/2)
(+ (+ (* x (log y)) (* (- b 1/2) (log c))) (* y i))
(+ (* x (log y)) (* (- b 1/2) (log c)))
(* x (log y))
(log y)
(/ (+ (* x (log y)) (+ t z)) a)
(log c)
Outputs
(+.f64 a (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(+.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (*.f64 y i)))
(+.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 y i))
(+.f64 (*.f64 y i) (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(+.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))
(+.f64 (+.f64 (*.f64 y i) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 (+.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(-.f64 (/.f64 (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))))
(fma.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a) (+.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(fma.f64 y i (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(fma.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64) (+.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(fma.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a) a (+.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c) (+.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (*.f64 y i)))
(fma.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (*.f64 y i)))
(fma.f64 i y (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(fma.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(fma.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))) (*.f64 y i))
(fma.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(fma.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 a (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 y i))
(fma.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 #s(literal 1 binary64) a) (+.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(fma.f64 (+.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a) #s(literal 1 binary64)) a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 3 binary64))) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 y i)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))))
(/.f64 (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))))
(/.f64 (neg.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))) (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))))
(/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 3 binary64)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64))) (-.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64))) (-.f64 (*.f64 y i) (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 a (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 a (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 a (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 a (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 a (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))))
(/.f64 (+.f64 (*.f64 a (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 a (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 a (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 a (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) #s(literal 1 binary64))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) #s(literal 1 binary64))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 a (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 a (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 a (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 a (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 a #s(literal 1 binary64))) (*.f64 a (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 a #s(literal 1 binary64))) (*.f64 a (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))) (*.f64 a (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))) (*.f64 a (neg.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)))))) (*.f64 a (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))) (*.f64 a (neg.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 a (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))) (*.f64 a (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 3 binary64))))) (*.f64 a (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (*.f64 a (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64))))) (*.f64 a (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 a (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))))) (*.f64 a (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))
(pow.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))))
(*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))))
(+.f64 a (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))
(+.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))
(+.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) a)
(+.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) a)
(-.f64 (/.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (+.f64 a (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (/.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (+.f64 a (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(fma.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a) a (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c) (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))
(fma.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)) (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))
(fma.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))
(fma.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(fma.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))
(fma.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(fma.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 #s(literal 1 binary64) a) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (+.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a) #s(literal 1 binary64)) a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (*.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (+.f64 a (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 a (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 a (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 a (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 a (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (neg.f64 (+.f64 a (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))
(/.f64 (+.f64 (*.f64 a (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))))
(/.f64 (+.f64 (*.f64 a (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 a (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 a (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))))
(/.f64 (+.f64 (*.f64 a (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 a (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))))
(/.f64 (+.f64 (*.f64 a (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 a (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) #s(literal 1 binary64))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) #s(literal 1 binary64))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 a (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 a (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 a #s(literal 1 binary64))) (*.f64 a (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 a #s(literal 1 binary64))) (*.f64 a (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))) (*.f64 a (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))))) (*.f64 a (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 a (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))))) (*.f64 a (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)) (*.f64 a (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 a (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))))) (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (*.f64 (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) #s(literal 1 binary64))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) #s(literal 1 binary64))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) #s(literal 1 binary64))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) #s(literal 1 binary64))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64))))) (*.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) a)) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) a) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) a))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (*.f64 a #s(literal 1 binary64)))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (*.f64 #s(literal 1 binary64) a))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) a) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) a))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (*.f64 a #s(literal 1 binary64)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (*.f64 #s(literal 1 binary64) a))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) a)) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) #s(literal 1 binary64))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) a) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) a))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) a)) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) a)) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (*.f64 a #s(literal 1 binary64)))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) a)) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (*.f64 #s(literal 1 binary64) a))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) a)) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) #s(literal 1 binary64))) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) a) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) a))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) a)) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) a)) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (*.f64 a #s(literal 1 binary64)))) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) a)) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a))) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (*.f64 #s(literal 1 binary64) a))) (*.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) a)) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 1 binary64))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) a) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) a))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 a #s(literal 1 binary64)))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 #s(literal 1 binary64) a))) (*.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) a)) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) #s(literal 1 binary64))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) a) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) a))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 a #s(literal 1 binary64)))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 #s(literal 1 binary64) a))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) a)) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 1 binary64))) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) a) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) a))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 a #s(literal 1 binary64)))) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) a)) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a))) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 #s(literal 1 binary64) a))) (*.f64 (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) a) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) a))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) (-.f64 #s(literal 0 binary64) a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) (-.f64 #s(literal 0 binary64) a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (*.f64 a #s(literal 1 binary64)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) (-.f64 #s(literal 0 binary64) a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (-.f64 #s(literal 0 binary64) a)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (*.f64 #s(literal 1 binary64) a))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(pow.f64 (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 a (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))))
(*.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 a (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(+.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))
(+.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)
(-.f64 (/.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)) (/.f64 (*.f64 a a) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)))
(fma.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a) a)
(fma.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64) a)
(fma.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a) a a)
(fma.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 #s(literal 1 binary64) a) a)
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))))
(/.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a))
(/.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)))
(/.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64))) (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))
(pow.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a) (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a (-.f64 a (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)))))))
(*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a) #s(literal 1 binary64)) a)
(/.f64 a (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))
(/.f64 #s(literal 1 binary64) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a)
(/.f64 (neg.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 #s(literal 0 binary64) a))
(/.f64 (*.f64 a (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (-.f64 #s(literal 0 binary64) a))
(/.f64 (*.f64 a #s(literal 1 binary64)) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))
(/.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a) (-.f64 #s(literal 0 binary64) a))
(/.f64 (*.f64 #s(literal 1 binary64) a) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))
(pow.f64 (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) #s(literal -1 binary64))
(*.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a))
(*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64))
(*.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a) a)
(*.f64 (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 #s(literal 1 binary64) a))
(+.f64 z (*.f64 y i))
(+.f64 (*.f64 y i) z)
(-.f64 (/.f64 (*.f64 z z) (-.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(fma.f64 y i z)
(fma.f64 i y z)
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (*.f64 z z) (*.f64 z (*.f64 y i)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (neg.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(/.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (neg.f64 (-.f64 z (*.f64 y i))))
(/.f64 (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 z z)) (-.f64 (*.f64 y i) z))
(pow.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(*.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))))
(*.f64 y i)
(*.f64 i y)
(+.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 a (*.f64 y i)))
(+.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) a)
(+.f64 (+.f64 (*.f64 y i) a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(-.f64 (/.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))))
(fma.f64 y i (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c) (+.f64 a (*.f64 y i)))
(fma.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)) (+.f64 a (*.f64 y i)))
(fma.f64 i y (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))) (*.f64 y i))
(fma.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 y i))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))))
(/.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))))
(/.f64 (neg.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))) (neg.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (-.f64 (*.f64 a a) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64))) (-.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(pow.f64 (/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i))) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(*.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 a (*.f64 y i)))))
(+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)
(-.f64 (/.f64 (*.f64 a a) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (/.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c) a)
(fma.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)) a)
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 a (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(/.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))))
(/.f64 (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (neg.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))
(pow.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a)))))
(*.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(+.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(+.f64 (*.f64 b (log.f64 c)) (*.f64 #s(literal -1/2 binary64) (log.f64 c)))
(fma.f64 b (log.f64 c) (*.f64 #s(literal -1/2 binary64) (log.f64 c)))
(fma.f64 (log.f64 c) b (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(/.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))))
(/.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 b #s(literal 1/2 binary64)))
(/.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))))
(/.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 b #s(literal 1/2 binary64)))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+.f64 b #s(literal -1/2 binary64))
(+.f64 #s(literal -1/2 binary64) b)
(-.f64 b #s(literal 1/2 binary64))
(-.f64 (/.f64 (*.f64 b (*.f64 b b)) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))) (/.f64 #s(literal 1/8 binary64) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(-.f64 (/.f64 (*.f64 b b) (+.f64 b #s(literal 1/2 binary64))) (/.f64 #s(literal 1/4 binary64) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))
(/.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (+.f64 b #s(literal 1/2 binary64)))
(/.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (-.f64 b #s(literal -1/2 binary64)))
(/.f64 (neg.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (neg.f64 (+.f64 b #s(literal 1/2 binary64))))
(pow.f64 (/.f64 (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64))) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal 1/2 binary64)))))
(*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (*.f64 x (log.f64 y)) (*.f64 y i)))
(+.f64 (*.f64 y i) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (*.f64 x (log.f64 y)))
(+.f64 (+.f64 (*.f64 y i) (*.f64 x (log.f64 y))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(-.f64 (/.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(fma.f64 x (log.f64 y) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(fma.f64 y i (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (log.f64 y) x (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c) (+.f64 (*.f64 x (log.f64 y)) (*.f64 y i)))
(fma.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)) (+.f64 (*.f64 x (log.f64 y)) (*.f64 y i)))
(fma.f64 i y (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 x (log.f64 y)))))) (*.f64 y i))
(fma.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 y i))
(/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))))
(/.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (neg.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))) (neg.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64))) (-.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))) (-.f64 (*.f64 y i) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(pow.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(*.f64 (-.f64 (pow.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x (log.f64 y)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 x (log.f64 y)))
(-.f64 (/.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (/.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(fma.f64 x (log.f64 y) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(fma.f64 (log.f64 y) x (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c) (*.f64 x (log.f64 y)))
(fma.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)) (*.f64 x (log.f64 y)))
(/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 x (log.f64 y))))))
(/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 x (*.f64 (log.f64 y) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 x (log.f64 y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (-.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 x (log.f64 y)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 x (log.f64 y))))
(pow.f64 (/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 x (log.f64 y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 x (log.f64 y)))))))
(*.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 y) x)
(log.f64 y)
(exp.f64 (*.f64 (log.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) #s(literal -1 binary64)))
(neg.f64 (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) (-.f64 #s(literal 0 binary64) a)))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) a))
(/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a)
(/.f64 (*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) #s(literal 1 binary64)) a)
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (-.f64 #s(literal 0 binary64) a))
(/.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (*.f64 a (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) (*.f64 x (log.f64 y)))))))
(/.f64 #s(literal 1 binary64) (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64)))
(/.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (+.f64 t z) (+.f64 t z))) (*.f64 a (-.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))
(/.f64 (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) #s(literal 1 binary64)) (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) (*.f64 x (log.f64 y))))) a))
(/.f64 (*.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (+.f64 t z) (+.f64 t z))) #s(literal 1 binary64)) (*.f64 (-.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))) (neg.f64 (-.f64 #s(literal 0 binary64) a)))
(/.f64 (*.f64 (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (/.f64 #s(literal 1 binary64) a)) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) (*.f64 x (log.f64 y))))))
(/.f64 (*.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (+.f64 t z) (+.f64 t z))) (/.f64 #s(literal 1 binary64) a)) (-.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))
(pow.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) (/.f64 #s(literal 1 binary64) a))
(*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) a)))
(*.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a))
(*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))
(*.f64 (/.f64 #s(literal 1 binary64) a) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 a (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) (*.f64 x (log.f64 y)))))))
(*.f64 (pow.f64 (/.f64 a (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (+.f64 t z) (+.f64 t z)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))
(log.f64 c)

simplify361.0ms (2.8%)

Algorithm
1×egg-herbie
Rules
4838×+-lowering-+.f64
4838×+-lowering-+.f32
4342×*-lowering-*.f32
4342×*-lowering-*.f64
1126×sum3-define
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
05268940
118288176
274948170
083608170
Stop Event
1×iter limit
1×node limit
Counts
708 → 708
Calls
Call 1
Inputs
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ t (+ z (* x (log y))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(+ a (+ t z))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+ a (+ z (* x (log y))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(+ a (+ t (* x (log y))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t z)
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(* x (log y))
(* x (+ (log y) (+ (/ t x) (/ z x))))
(* x (+ (log y) (+ (/ t x) (/ z x))))
(* x (+ (log y) (+ (/ t x) (/ z x))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+ z (* x (log y)))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
t
(* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))
(* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))
(* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))
t
(* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))
(+ t (* x (log y)))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
(+ t (+ z (* x (log y))))
z
(* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))
(* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))
(* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))
z
(* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))
(* i y)
(+ z (* i y))
(+ z (* i y))
(+ z (* i y))
z
(* z (+ 1 (/ (* i y) z)))
(* z (+ 1 (/ (* i y) z)))
(* z (+ 1 (/ (* i y) z)))
z
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
z
(+ z (* i y))
(+ z (* i y))
(+ z (* i y))
(* i y)
(* y (+ i (/ z y)))
(* y (+ i (/ z y)))
(* y (+ i (/ z y)))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
z
(+ z (* i y))
(+ z (* i y))
(+ z (* i y))
(* i y)
(* i (+ y (/ z i)))
(* i (+ y (/ z i)))
(* i (+ y (/ z i)))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(+ (* i y) (* (log c) (- b 1/2)))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
a
(* a (+ 1 (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))
(* a (+ 1 (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))
(* a (+ 1 (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))
a
(* -1 (* a (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) a)) 1)))
(+ a (+ (* -1/2 (log c)) (* i y)))
(+ a (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+ a (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+ a (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ (* i y) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ (* i y) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ (* i y) b)))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ (* -1/2 (log c)) (* i y))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ (* -1/2 (log c)) (* i y))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ (* -1/2 (log c)) (* i y))) b)))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ a (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ a (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ a (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ a (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ a (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ a (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ a (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ a (* (log c) (- b 1/2)))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(* i y)
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (* (log c) (- b 1/2))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (* (log c) (- b 1/2))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (* (log c) (- b 1/2))) y)))))
(+ a (* (log c) (- b 1/2)))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(* i y)
(* i (+ y (+ (/ a i) (/ (* (log c) (- b 1/2)) i))))
(* i (+ y (+ (/ a i) (/ (* (log c) (- b 1/2)) i))))
(* i (+ y (+ (/ a i) (/ (* (log c) (- b 1/2)) i))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (* (log c) (- b 1/2))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (* (log c) (- b 1/2))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (* (log c) (- b 1/2))) i)))))
(* (log c) (- b 1/2))
(+ a (* (log c) (- b 1/2)))
(+ a (* (log c) (- b 1/2)))
(+ a (* (log c) (- b 1/2)))
a
(* a (+ 1 (/ (* (log c) (- b 1/2)) a)))
(* a (+ 1 (/ (* (log c) (- b 1/2)) a)))
(* a (+ 1 (/ (* (log c) (- b 1/2)) a)))
a
(* -1 (* a (- (* -1 (/ (* (log c) (- b 1/2)) a)) 1)))
(* -1 (* a (- (* -1 (/ (* (log c) (- b 1/2)) a)) 1)))
(* -1 (* a (- (* -1 (/ (* (log c) (- b 1/2)) a)) 1)))
(+ a (* -1/2 (log c)))
(+ a (+ (* -1/2 (log c)) (* b (log c))))
(+ a (+ (* -1/2 (log c)) (* b (log c))))
(+ a (+ (* -1/2 (log c)) (* b (log c))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ a b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ a b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ a b))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* -1/2 (log c))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* -1/2 (log c))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* -1/2 (log c))) b)))))
(+ a (* (log c) (- b 1/2)))
(+ a (* (log c) (- b 1/2)))
(+ a (* (log c) (- b 1/2)))
(+ a (* (log c) (- b 1/2)))
(+ a (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+ a (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+ a (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+ a (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+ a (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+ a (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+ a (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+ a (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(* -1/2 (log c))
(+ (* -1/2 (log c)) (* b (log c)))
(+ (* -1/2 (log c)) (* b (log c)))
(+ (* -1/2 (log c)) (* b (log c)))
(* b (log c))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
-1/2
(- b 1/2)
(- b 1/2)
(- b 1/2)
b
(* b (- 1 (* 1/2 (/ 1 b))))
(* b (- 1 (* 1/2 (/ 1 b))))
(* b (- 1 (* 1/2 (/ 1 b))))
b
(* -1 (* b (- (* 1/2 (/ 1 b)) 1)))
(* -1 (* b (- (* 1/2 (/ 1 b)) 1)))
(* -1 (* b (- (* 1/2 (/ 1 b)) 1)))
(+ (* i y) (* (log c) (- b 1/2)))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(* x (log y))
(* x (+ (log y) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))
(* x (+ (log y) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))
(* x (+ (log y) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) x)))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (* (log c) (- b 1/2)) y))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))) y)))))
(+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))
(+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))
(+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))
(+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ (* i y) b) (/ (* x (log y)) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ (* i y) b) (/ (* x (log y)) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ (* i y) b) (/ (* x (log y)) b)))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))) b)))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))
(+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(* i y)
(* i (+ y (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))
(* i (+ y (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))
(* i (+ y (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) i)))))
(* (log c) (- b 1/2))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(* x (log y))
(* x (+ (log y) (/ (* (log c) (- b 1/2)) x)))
(* x (+ (log y) (/ (* (log c) (- b 1/2)) x)))
(* x (+ (log y) (/ (* (log c) (- b 1/2)) x)))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* (log c) (- b 1/2)) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* (log c) (- b 1/2)) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* (log c) (- b 1/2)) x)))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))
(+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))
(+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))
(+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))
(+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))
(+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))
(+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))
(+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))
(+ (* -1/2 (log c)) (* x (log y)))
(+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))
(+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))
(+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ (* x (log y)) b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ (* x (log y)) b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ (* x (log y)) b))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (* x (log y))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (* x (log y))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (* x (log y))) b)))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))
(+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(log y)
(log y)
(log y)
(log y)
(* -1 (log (/ 1 y)))
(* -1 (log (/ 1 y)))
(* -1 (log (/ 1 y)))
(* -1 (log (/ 1 y)))
(+ (log -1) (* -1 (log (/ -1 y))))
(+ (log -1) (* -1 (log (/ -1 y))))
(+ (log -1) (* -1 (log (/ -1 y))))
(+ (log -1) (* -1 (log (/ -1 y))))
(/ (+ t z) a)
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(/ (* x (log y)) a)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (log y) a))))
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (log y) a))))
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (log y) a))))
(/ (* x (log y)) a)
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (/ z a)) x)))))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (/ z a)) x)))))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (/ z a)) x)))))
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* -1 (* x (log (/ 1 y)))))) a)
(/ (+ t (+ z (* -1 (* x (log (/ 1 y)))))) a)
(/ (+ t (+ z (* -1 (* x (log (/ 1 y)))))) a)
(/ (+ t (+ z (* -1 (* x (log (/ 1 y)))))) a)
(/ (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))) a)
(/ (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))) a)
(/ (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))) a)
(/ (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))) a)
(/ (+ z (* x (log y))) a)
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(/ t a)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* x (log y)) (* a t)))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* x (log y)) (* a t)))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* x (log y)) (* a t)))))
(/ t a)
(* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* x (log y)) a)) t)) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* x (log y)) a)) t)) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* x (log y)) a)) t)) (/ 1 a))))
(/ (+ t (* x (log y))) a)
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(/ z a)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* x (log y)) (* a z)))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* x (log y)) (* a z)))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* x (log y)) (* a z)))))
(/ z a)
(* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* x (log y)) a)) z)) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* x (log y)) a)) z)) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* x (log y)) a)) z)) (/ 1 a))))
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(log c)
(log c)
(log c)
(log c)
(* -1 (log (/ 1 c)))
(* -1 (log (/ 1 c)))
(* -1 (log (/ 1 c)))
(* -1 (log (/ 1 c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ (log -1) (* -1 (log (/ -1 c))))
Outputs
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 t a) (+.f64 (/.f64 z a) (+.f64 (/.f64 (*.f64 x (log.f64 y)) a) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))) (/.f64 (*.f64 i y) a))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 t a) (+.f64 (/.f64 z a) (+.f64 (/.f64 (*.f64 x (log.f64 y)) a) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))) (/.f64 (*.f64 i y) a))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 t a) (+.f64 (/.f64 z a) (+.f64 (/.f64 (*.f64 x (log.f64 y)) a) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))) (/.f64 (*.f64 i y) a))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 (+.f64 t (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y)))) (*.f64 x (log.f64 y))) a))) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 (+.f64 t (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y)))) (*.f64 x (log.f64 y))) a))) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 (+.f64 t (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y)))) (*.f64 x (log.f64 y))) a))) (neg.f64 a))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (+.f64 (/.f64 (*.f64 i y) x) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x)) (+.f64 (/.f64 t x) (/.f64 z x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (+.f64 (/.f64 (*.f64 i y) x) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x)) (+.f64 (/.f64 t x) (/.f64 z x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (+.f64 (/.f64 (*.f64 i y) x) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x)) (+.f64 (/.f64 t x) (/.f64 z x))))))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (*.f64 (neg.f64 x) #s(literal -1 binary64)) (+.f64 (log.f64 y) (/.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (+.f64 t a)) x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (*.f64 (neg.f64 x) #s(literal -1 binary64)) (+.f64 (log.f64 y) (/.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (+.f64 t a)) x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (*.f64 (neg.f64 x) #s(literal -1 binary64)) (+.f64 (log.f64 y) (/.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (+.f64 t a)) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 y (+.f64 i (+.f64 (/.f64 (*.f64 x (log.f64 y)) y) (+.f64 (/.f64 a y) (+.f64 (/.f64 t y) (+.f64 (/.f64 z y) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 y (+.f64 i (+.f64 (/.f64 (*.f64 x (log.f64 y)) y) (+.f64 (/.f64 a y) (+.f64 (/.f64 t y) (+.f64 (/.f64 z y) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 y (+.f64 i (+.f64 (/.f64 (*.f64 x (log.f64 y)) y) (+.f64 (/.f64 a y) (+.f64 (/.f64 t y) (+.f64 (/.f64 z y) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y)))))))
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) i) (/.f64 (+.f64 a (+.f64 (+.f64 z (+.f64 t (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))) y)) (-.f64 #s(literal 0 binary64) y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) i) (/.f64 (+.f64 a (+.f64 (+.f64 z (+.f64 t (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))) y)) (-.f64 #s(literal 0 binary64) y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) i) (/.f64 (+.f64 a (+.f64 (+.f64 z (+.f64 t (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))) y)) (-.f64 #s(literal 0 binary64) y))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (+.f64 z a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(*.f64 t (+.f64 (+.f64 (/.f64 z t) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) t) (+.f64 (/.f64 (*.f64 i y) t) (/.f64 (*.f64 x (log.f64 y)) t)))) (+.f64 #s(literal 1 binary64) (/.f64 a t))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(*.f64 t (+.f64 (+.f64 (/.f64 z t) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) t) (+.f64 (/.f64 (*.f64 i y) t) (/.f64 (*.f64 x (log.f64 y)) t)))) (+.f64 #s(literal 1 binary64) (/.f64 a t))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(*.f64 t (+.f64 (+.f64 (/.f64 z t) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) t) (+.f64 (/.f64 (*.f64 i y) t) (/.f64 (*.f64 x (log.f64 y)) t)))) (+.f64 #s(literal 1 binary64) (/.f64 a t))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (+.f64 z a)) (neg.f64 t))) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (+.f64 z a)) (neg.f64 t))) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (+.f64 z a)) (neg.f64 t))) (neg.f64 t))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(*.f64 z (+.f64 (+.f64 (+.f64 (/.f64 (*.f64 i y) z) (/.f64 (*.f64 x (log.f64 y)) z)) (+.f64 (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z)) (/.f64 t z))) (+.f64 #s(literal 1 binary64) (/.f64 a z))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(*.f64 z (+.f64 (+.f64 (+.f64 (/.f64 (*.f64 i y) z) (/.f64 (*.f64 x (log.f64 y)) z)) (+.f64 (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z)) (/.f64 t z))) (+.f64 #s(literal 1 binary64) (/.f64 a z))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(*.f64 z (+.f64 (+.f64 (+.f64 (/.f64 (*.f64 i y) z) (/.f64 (*.f64 x (log.f64 y)) z)) (+.f64 (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z)) (/.f64 t z))) (+.f64 #s(literal 1 binary64) (/.f64 a z))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (+.f64 t a)) (neg.f64 z))) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (+.f64 t a)) (neg.f64 z))) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (+.f64 t a)) (neg.f64 z))) (neg.f64 z))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 t a))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (+.f64 (/.f64 t b) (+.f64 (/.f64 z b) (+.f64 (/.f64 (*.f64 i y) b) (/.f64 (*.f64 x (log.f64 y)) b)))) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (/.f64 a b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (+.f64 (/.f64 t b) (+.f64 (/.f64 z b) (+.f64 (/.f64 (*.f64 i y) b) (/.f64 (*.f64 x (log.f64 y)) b)))) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (/.f64 a b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (+.f64 (/.f64 t b) (+.f64 (/.f64 z b) (+.f64 (/.f64 (*.f64 i y) b) (/.f64 (*.f64 x (log.f64 y)) b)))) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (/.f64 a b)))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 t a)) (neg.f64 b)) (log.f64 c)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 t a)) (neg.f64 b)) (log.f64 c)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 z (+.f64 (*.f64 i y) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 t a)) (neg.f64 b)) (log.f64 c)) (neg.f64 b))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) (+.f64 z (*.f64 i y))) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) (+.f64 z (*.f64 i y))) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) (+.f64 z (*.f64 i y))) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) (+.f64 z (*.f64 i y))) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z (*.f64 i y))) (*.f64 x (log.f64 y))) (+.f64 t a))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 i (+.f64 y (+.f64 (+.f64 (/.f64 (*.f64 x (log.f64 y)) i) (+.f64 (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)) (/.f64 z i))) (+.f64 (/.f64 a i) (/.f64 t i)))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 i (+.f64 y (+.f64 (+.f64 (/.f64 (*.f64 x (log.f64 y)) i) (+.f64 (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)) (/.f64 z i))) (+.f64 (/.f64 a i) (/.f64 t i)))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 i (+.f64 y (+.f64 (+.f64 (/.f64 (*.f64 x (log.f64 y)) i) (+.f64 (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)) (/.f64 z i))) (+.f64 (/.f64 a i) (/.f64 t i)))))
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 #s(literal 0 binary64) i) (-.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 (+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y)))))) i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 #s(literal 0 binary64) i) (-.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 (+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y)))))) i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 #s(literal 0 binary64) i) (-.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 (+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y)))))) i)))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(*.f64 a (+.f64 (+.f64 (/.f64 z a) (+.f64 (/.f64 (*.f64 x (log.f64 y)) a) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (+.f64 #s(literal 1 binary64) (/.f64 t a))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(*.f64 a (+.f64 (+.f64 (/.f64 z a) (+.f64 (/.f64 (*.f64 x (log.f64 y)) a) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (+.f64 #s(literal 1 binary64) (/.f64 t a))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(*.f64 a (+.f64 (+.f64 (/.f64 z a) (+.f64 (/.f64 (*.f64 x (log.f64 y)) a) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (+.f64 #s(literal 1 binary64) (/.f64 t a))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))) a))) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))) a))) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))) a))) (neg.f64 a))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t z) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x) (+.f64 (/.f64 t x) (/.f64 z x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x) (+.f64 (/.f64 t x) (/.f64 z x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x) (+.f64 (/.f64 t x) (/.f64 z x))))))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (*.f64 (neg.f64 x) #s(literal -1 binary64)) (+.f64 (log.f64 y) (/.f64 (+.f64 (+.f64 t z) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (*.f64 (neg.f64 x) #s(literal -1 binary64)) (+.f64 (log.f64 y) (/.f64 (+.f64 (+.f64 t z) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) x)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (*.f64 (neg.f64 x) #s(literal -1 binary64)) (+.f64 (log.f64 y) (/.f64 (+.f64 (+.f64 t z) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 (+.f64 z (+.f64 t (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 (+.f64 z (+.f64 t (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 (+.f64 z (+.f64 t (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 (+.f64 z (+.f64 t (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (+.f64 z a))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(*.f64 t (+.f64 (+.f64 (+.f64 (/.f64 z t) (/.f64 (*.f64 x (log.f64 y)) t)) (+.f64 #s(literal 1 binary64) (/.f64 a t))) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) t)))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(*.f64 t (+.f64 (+.f64 (+.f64 (/.f64 z t) (/.f64 (*.f64 x (log.f64 y)) t)) (+.f64 #s(literal 1 binary64) (/.f64 a t))) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) t)))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(*.f64 t (+.f64 (+.f64 (+.f64 (/.f64 z t) (/.f64 (*.f64 x (log.f64 y)) t)) (+.f64 #s(literal 1 binary64) (/.f64 a t))) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) t)))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (+.f64 z a)) (neg.f64 t))) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (+.f64 z a)) (neg.f64 t))) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (+.f64 z a)) (neg.f64 t))) (neg.f64 t))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 a (+.f64 t (*.f64 x (log.f64 y)))) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 (*.f64 x (log.f64 y)) z) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))) (+.f64 (/.f64 a z) (/.f64 t z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 (*.f64 x (log.f64 y)) z) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))) (+.f64 (/.f64 a z) (/.f64 t z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 (*.f64 x (log.f64 y)) z) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))) (+.f64 (/.f64 a z) (/.f64 t z)))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 a (+.f64 t (*.f64 x (log.f64 y)))) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (neg.f64 z))) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 a (+.f64 t (*.f64 x (log.f64 y)))) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (neg.f64 z))) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 a (+.f64 t (*.f64 x (log.f64 y)))) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (neg.f64 z))) (neg.f64 z))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+.f64 (+.f64 z (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (+.f64 t a))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (+.f64 (/.f64 t b) (+.f64 (/.f64 z b) (/.f64 (*.f64 x (log.f64 y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (+.f64 (/.f64 t b) (+.f64 (/.f64 z b) (/.f64 (*.f64 x (log.f64 y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (+.f64 (/.f64 t b) (+.f64 (/.f64 z b) (/.f64 (*.f64 x (log.f64 y)) b)))))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 c)) (/.f64 (+.f64 (+.f64 z (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (+.f64 t a)) b)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 c)) (/.f64 (+.f64 (+.f64 z (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (+.f64 t a)) b)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 c)) (/.f64 (+.f64 (+.f64 z (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (+.f64 t a)) b)) (neg.f64 b))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 a (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 t (*.f64 x (log.f64 y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y))))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y))))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y))))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y))))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(*.f64 a (+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (+.f64 (/.f64 (*.f64 x (log.f64 y)) a) #s(literal 1 binary64))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(*.f64 a (+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (+.f64 (/.f64 (*.f64 x (log.f64 y)) a) #s(literal 1 binary64))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(*.f64 a (+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (+.f64 (/.f64 (*.f64 x (log.f64 y)) a) #s(literal 1 binary64))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) (neg.f64 a))) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) (neg.f64 a))) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) (neg.f64 a))) (neg.f64 a))
(+ a (+ t z))
(+.f64 t (+.f64 z a))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (/.f64 t x) (/.f64 z x)))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (/.f64 t x) (/.f64 z x)))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 a x) (+.f64 (/.f64 t x) (/.f64 z x)))))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 y)) (/.f64 (+.f64 t (+.f64 z a)) x)) (neg.f64 x))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 y)) (/.f64 (+.f64 t (+.f64 z a)) x)) (neg.f64 x))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 y)) (/.f64 (+.f64 t (+.f64 z a)) x)) (neg.f64 x))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+.f64 a (+.f64 t (+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+.f64 a (+.f64 t (+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+.f64 a (+.f64 t (+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+.f64 a (+.f64 t (+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))))
(+ a (+ z (* x (log y))))
(+.f64 z (+.f64 (*.f64 x (log.f64 y)) a))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(*.f64 t (+.f64 (+.f64 (/.f64 z t) (/.f64 (*.f64 x (log.f64 y)) t)) (+.f64 #s(literal 1 binary64) (/.f64 a t))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(*.f64 t (+.f64 (+.f64 (/.f64 z t) (/.f64 (*.f64 x (log.f64 y)) t)) (+.f64 #s(literal 1 binary64) (/.f64 a t))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(*.f64 t (+.f64 (+.f64 (/.f64 z t) (/.f64 (*.f64 x (log.f64 y)) t)) (+.f64 #s(literal 1 binary64) (/.f64 a t))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z (+.f64 (*.f64 x (log.f64 y)) a)) (neg.f64 t))) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z (+.f64 (*.f64 x (log.f64 y)) a)) (neg.f64 t))) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z (+.f64 (*.f64 x (log.f64 y)) a)) (neg.f64 t))) (neg.f64 t))
(+ a (+ t (* x (log y))))
(+.f64 a (+.f64 t (*.f64 x (log.f64 y))))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 a (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(*.f64 z (+.f64 (/.f64 a z) (+.f64 (/.f64 (*.f64 x (log.f64 y)) z) (+.f64 #s(literal 1 binary64) (/.f64 t z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(*.f64 z (+.f64 (/.f64 a z) (+.f64 (/.f64 (*.f64 x (log.f64 y)) z) (+.f64 #s(literal 1 binary64) (/.f64 t z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(*.f64 z (+.f64 (/.f64 a z) (+.f64 (/.f64 (*.f64 x (log.f64 y)) z) (+.f64 #s(literal 1 binary64) (/.f64 t z)))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 a (+.f64 t (*.f64 x (log.f64 y)))) z))) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 a (+.f64 t (*.f64 x (log.f64 y)))) z))) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 a (+.f64 t (*.f64 x (log.f64 y)))) z))) (neg.f64 z))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t z)
(+.f64 t z)
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (+ (log y) (+ (/ t x) (/ z x))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 t x) (/.f64 z x))))
(* x (+ (log y) (+ (/ t x) (/ z x))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 t x) (/.f64 z x))))
(* x (+ (log y) (+ (/ t x) (/ z x))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (/.f64 t x) (/.f64 z x))))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 y)) (/.f64 (+.f64 t z) x)) (neg.f64 x))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 y)) (/.f64 (+.f64 t z) x)) (neg.f64 x))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 y)) (/.f64 (+.f64 t z) x)) (neg.f64 x))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* -1 (* x (log (/ 1 y))))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+.f64 t (+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+.f64 t (+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+.f64 t (+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
(+.f64 t (+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ z (* x (log y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
t
(* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))
(*.f64 t (+.f64 (/.f64 z t) (+.f64 (/.f64 (*.f64 x (log.f64 y)) t) #s(literal 1 binary64))))
(* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))
(*.f64 t (+.f64 (/.f64 z t) (+.f64 (/.f64 (*.f64 x (log.f64 y)) t) #s(literal 1 binary64))))
(* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))
(*.f64 t (+.f64 (/.f64 z t) (+.f64 (/.f64 (*.f64 x (log.f64 y)) t) #s(literal 1 binary64))))
t
(* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z (*.f64 x (log.f64 y))) (neg.f64 t))) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z (*.f64 x (log.f64 y))) (neg.f64 t))) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z (*.f64 x (log.f64 y))) (neg.f64 t))) (neg.f64 t))
(+ t (* x (log y)))
(+.f64 t (*.f64 x (log.f64 y)))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
(+ t (+ z (* x (log y))))
(+.f64 z (+.f64 t (*.f64 x (log.f64 y))))
z
(* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))
(*.f64 z (+.f64 (/.f64 (*.f64 x (log.f64 y)) z) (+.f64 #s(literal 1 binary64) (/.f64 t z))))
(* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))
(*.f64 z (+.f64 (/.f64 (*.f64 x (log.f64 y)) z) (+.f64 #s(literal 1 binary64) (/.f64 t z))))
(* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))
(*.f64 z (+.f64 (/.f64 (*.f64 x (log.f64 y)) z) (+.f64 #s(literal 1 binary64) (/.f64 t z))))
z
(* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (*.f64 #s(literal -1 binary64) (+.f64 t (*.f64 x (log.f64 y)))) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (*.f64 #s(literal -1 binary64) (+.f64 t (*.f64 x (log.f64 y)))) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (*.f64 #s(literal -1 binary64) (+.f64 t (*.f64 x (log.f64 y)))) z)) (neg.f64 z))
(* i y)
(*.f64 i y)
(+ z (* i y))
(+.f64 z (*.f64 i y))
(+ z (* i y))
(+.f64 z (*.f64 i y))
(+ z (* i y))
(+.f64 z (*.f64 i y))
z
(* z (+ 1 (/ (* i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(* z (+ 1 (/ (* i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(* z (+ 1 (/ (* i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
z
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 i y) z))) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 i y) z))) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 i y) z))) (neg.f64 z))
z
(+ z (* i y))
(+.f64 z (*.f64 i y))
(+ z (* i y))
(+.f64 z (*.f64 i y))
(+ z (* i y))
(+.f64 z (*.f64 i y))
(* i y)
(*.f64 i y)
(* y (+ i (/ z y)))
(*.f64 y (+.f64 i (/.f64 z y)))
(* y (+ i (/ z y)))
(*.f64 y (+.f64 i (/.f64 z y)))
(* y (+ i (/ z y)))
(*.f64 y (+.f64 i (/.f64 z y)))
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
(-.f64 #s(literal 0 binary64) (*.f64 y (-.f64 (/.f64 z (-.f64 #s(literal 0 binary64) y)) i)))
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
(-.f64 #s(literal 0 binary64) (*.f64 y (-.f64 (/.f64 z (-.f64 #s(literal 0 binary64) y)) i)))
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
(-.f64 #s(literal 0 binary64) (*.f64 y (-.f64 (/.f64 z (-.f64 #s(literal 0 binary64) y)) i)))
z
(+ z (* i y))
(+.f64 z (*.f64 i y))
(+ z (* i y))
(+.f64 z (*.f64 i y))
(+ z (* i y))
(+.f64 z (*.f64 i y))
(* i y)
(*.f64 i y)
(* i (+ y (/ z i)))
(*.f64 i (+.f64 y (/.f64 z i)))
(* i (+ y (/ z i)))
(*.f64 i (+.f64 y (/.f64 z i)))
(* i (+ y (/ z i)))
(*.f64 i (+.f64 y (/.f64 z i)))
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) i) #s(literal -1 binary64)) (+.f64 y (/.f64 z i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) i) #s(literal -1 binary64)) (+.f64 y (/.f64 z i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(*.f64 (*.f64 (-.f64 #s(literal 0 binary64) i) #s(literal -1 binary64)) (+.f64 y (/.f64 z i)))
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(+ (* i y) (* (log c) (- b 1/2)))
(+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
a
(* a (+ 1 (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))
(*.f64 a (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) a))))
(* a (+ 1 (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))
(*.f64 a (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) a))))
(* a (+ 1 (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))
(*.f64 a (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) a))))
a
(* -1 (* a (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (neg.f64 a))) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (neg.f64 a))) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (neg.f64 a))) (neg.f64 a))
(+ a (+ (* -1/2 (log c)) (* i y)))
(+.f64 (*.f64 i y) (+.f64 a (*.f64 (log.f64 c) #s(literal -1/2 binary64))))
(+ a (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ (* i y) b)))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (/.f64 (*.f64 i y) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ (* i y) b)))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (/.f64 (*.f64 i y) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ (* i y) b)))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (/.f64 (*.f64 i y) b)))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ (* -1/2 (log c)) (* i y))) b)))))
(-.f64 #s(literal 0 binary64) (*.f64 (neg.f64 b) (+.f64 (log.f64 c) (/.f64 (+.f64 (*.f64 i y) (+.f64 a (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ (* -1/2 (log c)) (* i y))) b)))))
(-.f64 #s(literal 0 binary64) (*.f64 (neg.f64 b) (+.f64 (log.f64 c) (/.f64 (+.f64 (*.f64 i y) (+.f64 a (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ (* -1/2 (log c)) (* i y))) b)))))
(-.f64 #s(literal 0 binary64) (*.f64 (neg.f64 b) (+.f64 (log.f64 c) (/.f64 (+.f64 (*.f64 i y) (+.f64 a (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (*.f64 i y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (*.f64 i y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (*.f64 i y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (*.f64 i y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(* i y)
(*.f64 i y)
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 (/.f64 a y) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) i)))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 (/.f64 a y) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) i)))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 (/.f64 a y) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) i)))
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (* (log c) (- b 1/2))) y)))))
(-.f64 #s(literal 0 binary64) (*.f64 y (-.f64 (-.f64 #s(literal 0 binary64) i) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) y))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (* (log c) (- b 1/2))) y)))))
(-.f64 #s(literal 0 binary64) (*.f64 y (-.f64 (-.f64 #s(literal 0 binary64) i) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) y))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (* (log c) (- b 1/2))) y)))))
(-.f64 #s(literal 0 binary64) (*.f64 y (-.f64 (-.f64 #s(literal 0 binary64) i) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) y))))
(+ a (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) a))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 i (+.f64 y (+.f64 (/.f64 a i) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)))))
(* i (+ y (+ (/ a i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 i (+.f64 y (+.f64 (/.f64 a i) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)))))
(* i (+ y (+ (/ a i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 i (+.f64 y (+.f64 (/.f64 a i) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)))))
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (* (log c) (- b 1/2))) i)))))
(*.f64 (-.f64 #s(literal 0 binary64) i) (-.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (* (log c) (- b 1/2))) i)))))
(*.f64 (-.f64 #s(literal 0 binary64) i) (-.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (* (log c) (- b 1/2))) i)))))
(*.f64 (-.f64 #s(literal 0 binary64) i) (-.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) i)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+ a (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
a
(* a (+ 1 (/ (* (log c) (- b 1/2)) a)))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
(* a (+ 1 (/ (* (log c) (- b 1/2)) a)))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
(* a (+ 1 (/ (* (log c) (- b 1/2)) a)))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
a
(* -1 (* a (- (* -1 (/ (* (log c) (- b 1/2)) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (* (log c) (- b 1/2)) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (* (log c) (- b 1/2)) a)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (neg.f64 a))
(+ a (* -1/2 (log c)))
(+.f64 a (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(+ a (+ (* -1/2 (log c)) (* b (log c))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (+ (* -1/2 (log c)) (* b (log c))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (+ (* -1/2 (log c)) (* b (log c))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ a b))))
(*.f64 b (+.f64 (/.f64 a b) (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ a b))))
(*.f64 b (+.f64 (/.f64 a b) (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ a b))))
(*.f64 b (+.f64 (/.f64 a b) (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* -1/2 (log c))) b)))))
(*.f64 (-.f64 (/.f64 (+.f64 a (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 b)) (log.f64 c)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* -1/2 (log c))) b)))))
(*.f64 (-.f64 (/.f64 (+.f64 a (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 b)) (log.f64 c)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* -1/2 (log c))) b)))))
(*.f64 (-.f64 (/.f64 (+.f64 a (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 b)) (log.f64 c)) (neg.f64 b))
(+ a (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(* -1/2 (log c))
(*.f64 (log.f64 c) #s(literal -1/2 binary64))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 c) b)) (log.f64 c)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 c) b)) (log.f64 c)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 c) b)) (log.f64 c)) (neg.f64 b))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
-1/2
#s(literal -1/2 binary64)
(- b 1/2)
(+.f64 b #s(literal -1/2 binary64))
(- b 1/2)
(+.f64 b #s(literal -1/2 binary64))
(- b 1/2)
(+.f64 b #s(literal -1/2 binary64))
b
(* b (- 1 (* 1/2 (/ 1 b))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) b)))
(* b (- 1 (* 1/2 (/ 1 b))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) b)))
(* b (- 1 (* 1/2 (/ 1 b))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) b)))
b
(* -1 (* b (- (* 1/2 (/ 1 b)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 #s(literal 1/2 binary64) b)) (neg.f64 b))
(* -1 (* b (- (* 1/2 (/ 1 b)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 #s(literal 1/2 binary64) b)) (neg.f64 b))
(* -1 (* b (- (* 1/2 (/ 1 b)) 1)))
(*.f64 (+.f64 #s(literal -1 binary64) (/.f64 #s(literal 1/2 binary64) b)) (neg.f64 b))
(+ (* i y) (* (log c) (- b 1/2)))
(+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (+ (log y) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))
(*.f64 x (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x) (+.f64 (log.f64 y) (/.f64 (*.f64 i y) x))))
(* x (+ (log y) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))
(*.f64 x (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x) (+.f64 (log.f64 y) (/.f64 (*.f64 i y) x))))
(* x (+ (log y) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))
(*.f64 x (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x) (+.f64 (log.f64 y) (/.f64 (*.f64 i y) x))))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) x)))))
(-.f64 #s(literal 0 binary64) (*.f64 (neg.f64 x) (+.f64 (log.f64 y) (/.f64 (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) x))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) x)))))
(-.f64 #s(literal 0 binary64) (*.f64 (neg.f64 x) (+.f64 (log.f64 y) (/.f64 (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) x))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) x)))))
(-.f64 #s(literal 0 binary64) (*.f64 (neg.f64 x) (+.f64 (log.f64 y) (/.f64 (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) x))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) (+.f64 i (/.f64 (*.f64 x (log.f64 y)) y))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) (+.f64 i (/.f64 (*.f64 x (log.f64 y)) y))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) (+.f64 i (/.f64 (*.f64 x (log.f64 y)) y))))
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))) y)))))
(*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 (-.f64 #s(literal 0 binary64) i) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))) y)))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))) y)))))
(*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 (-.f64 #s(literal 0 binary64) i) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))) y)))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))) y)))))
(*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 (-.f64 #s(literal 0 binary64) i) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))) y)))
(+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))
(+.f64 (*.f64 i y) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))
(+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ (* i y) b) (/ (* x (log y)) b)))))
(*.f64 b (+.f64 (+.f64 (/.f64 (*.f64 x (log.f64 y)) b) (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b))) (/.f64 (*.f64 i y) b)))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ (* i y) b) (/ (* x (log y)) b)))))
(*.f64 b (+.f64 (+.f64 (/.f64 (*.f64 x (log.f64 y)) b) (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b))) (/.f64 (*.f64 i y) b)))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ (* i y) b) (/ (* x (log y)) b)))))
(*.f64 b (+.f64 (+.f64 (/.f64 (*.f64 x (log.f64 y)) b) (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b))) (/.f64 (*.f64 i y) b)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))) b)))))
(*.f64 (*.f64 (neg.f64 b) #s(literal -1 binary64)) (+.f64 (log.f64 c) (/.f64 (+.f64 (*.f64 i y) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))) b)))))
(*.f64 (*.f64 (neg.f64 b) #s(literal -1 binary64)) (+.f64 (log.f64 c) (/.f64 (+.f64 (*.f64 i y) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))) b)))))
(*.f64 (*.f64 (neg.f64 b) #s(literal -1 binary64)) (+.f64 (log.f64 c) (/.f64 (+.f64 (*.f64 i y) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b)))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (+.f64 (*.f64 i y) (*.f64 x (log.f64 y))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (+.f64 (*.f64 i y) (*.f64 x (log.f64 y))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (+.f64 (*.f64 i y) (*.f64 x (log.f64 y))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (+.f64 (*.f64 i y) (*.f64 x (log.f64 y))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 i (+.f64 (/.f64 (*.f64 x (log.f64 y)) i) (+.f64 (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)) y)))
(* i (+ y (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 i (+.f64 (/.f64 (*.f64 x (log.f64 y)) i) (+.f64 (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)) y)))
(* i (+ y (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 i (+.f64 (/.f64 (*.f64 x (log.f64 y)) i) (+.f64 (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)) y)))
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) i)))))
(*.f64 (-.f64 #s(literal 0 binary64) i) (-.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) i)))))
(*.f64 (-.f64 #s(literal 0 binary64) i) (-.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) i)))))
(*.f64 (-.f64 #s(literal 0 binary64) i) (-.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) i)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (+ (log y) (/ (* (log c) (- b 1/2)) x)))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x)))
(* x (+ (log y) (/ (* (log c) (- b 1/2)) x)))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x)))
(* x (+ (log y) (/ (* (log c) (- b 1/2)) x)))
(*.f64 x (+.f64 (log.f64 y) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x)))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* (log c) (- b 1/2)) x)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 y)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x)) (neg.f64 x))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* (log c) (- b 1/2)) x)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 y)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x)) (neg.f64 x))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* (log c) (- b 1/2)) x)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 y)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x)) (neg.f64 x))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))
(+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))
(+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))
(+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))
(+ (* -1/2 (log c)) (* x (log y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ (* x (log y)) b))))
(*.f64 b (+.f64 (/.f64 (*.f64 x (log.f64 y)) b) (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ (* x (log y)) b))))
(*.f64 b (+.f64 (/.f64 (*.f64 x (log.f64 y)) b) (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ (* x (log y)) b))))
(*.f64 b (+.f64 (/.f64 (*.f64 x (log.f64 y)) b) (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (* x (log y))) b)))))
(*.f64 (*.f64 (neg.f64 b) #s(literal -1 binary64)) (+.f64 (log.f64 c) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) b)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (* x (log y))) b)))))
(*.f64 (*.f64 (neg.f64 b) #s(literal -1 binary64)) (+.f64 (log.f64 c) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) b)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -1/2 (log c)) (* x (log y))) b)))))
(*.f64 (*.f64 (neg.f64 b) #s(literal -1 binary64)) (+.f64 (log.f64 c) (/.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) b)))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (log (/ 1 y))))
(*.f64 x (log.f64 y))
(* -1 (* x (log (/ 1 y))))
(*.f64 x (log.f64 y))
(* -1 (* x (log (/ 1 y))))
(*.f64 x (log.f64 y))
(* -1 (* x (log (/ 1 y))))
(*.f64 x (log.f64 y))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))
(log y)
(log.f64 y)
(log y)
(log.f64 y)
(log y)
(log.f64 y)
(log y)
(log.f64 y)
(* -1 (log (/ 1 y)))
(log.f64 y)
(* -1 (log (/ 1 y)))
(log.f64 y)
(* -1 (log (/ 1 y)))
(log.f64 y)
(* -1 (log (/ 1 y)))
(log.f64 y)
(+ (log -1) (* -1 (log (/ -1 y))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))
(+ (log -1) (* -1 (log (/ -1 y))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))
(+ (log -1) (* -1 (log (/ -1 y))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))
(+ (log -1) (* -1 (log (/ -1 y))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))
(/ (+ t z) a)
(/.f64 (+.f64 t z) a)
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+.f64 (/.f64 t a) (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)))
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+.f64 (/.f64 t a) (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)))
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+.f64 (/.f64 t a) (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)))
(/ (* x (log y)) a)
(/.f64 (*.f64 x (log.f64 y)) a)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (log y) a))))
(*.f64 x (+.f64 (/.f64 (/.f64 t a) x) (+.f64 (/.f64 (/.f64 z a) x) (/.f64 (log.f64 y) a))))
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (log y) a))))
(*.f64 x (+.f64 (/.f64 (/.f64 t a) x) (+.f64 (/.f64 (/.f64 z a) x) (/.f64 (log.f64 y) a))))
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (log y) a))))
(*.f64 x (+.f64 (/.f64 (/.f64 t a) x) (+.f64 (/.f64 (/.f64 z a) x) (/.f64 (log.f64 y) a))))
(/ (* x (log y)) a)
(/.f64 (*.f64 x (log.f64 y)) a)
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (/ z a)) x)))))
(*.f64 (-.f64 (/.f64 (-.f64 #s(literal 0 binary64) (log.f64 y)) a) (/.f64 (+.f64 (/.f64 t a) (/.f64 z a)) x)) (neg.f64 x))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (/ z a)) x)))))
(*.f64 (-.f64 (/.f64 (-.f64 #s(literal 0 binary64) (log.f64 y)) a) (/.f64 (+.f64 (/.f64 t a) (/.f64 z a)) x)) (neg.f64 x))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (/ z a)) x)))))
(*.f64 (-.f64 (/.f64 (-.f64 #s(literal 0 binary64) (log.f64 y)) a) (/.f64 (+.f64 (/.f64 t a) (/.f64 z a)) x)) (neg.f64 x))
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* -1 (* x (log (/ 1 y)))))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* -1 (* x (log (/ 1 y)))))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* -1 (* x (log (/ 1 y)))))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* -1 (* x (log (/ 1 y)))))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))) a)
(/.f64 (+.f64 t (+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))) a)
(/ (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))) a)
(/.f64 (+.f64 t (+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))) a)
(/ (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))) a)
(/.f64 (+.f64 t (+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))) a)
(/ (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))) a)
(/.f64 (+.f64 t (+.f64 z (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))))) a)
(/ (+ z (* x (log y))) a)
(/.f64 (+.f64 z (*.f64 x (log.f64 y))) a)
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+.f64 (/.f64 t a) (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)))
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+.f64 (/.f64 t a) (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)))
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+.f64 (/.f64 t a) (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)))
(/ t a)
(/.f64 t a)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* x (log y)) (* a t)))))
(*.f64 t (+.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 (/.f64 z (*.f64 t a)) (/.f64 (/.f64 (*.f64 x (log.f64 y)) a) t))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* x (log y)) (* a t)))))
(*.f64 t (+.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 (/.f64 z (*.f64 t a)) (/.f64 (/.f64 (*.f64 x (log.f64 y)) a) t))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* x (log y)) (* a t)))))
(*.f64 t (+.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 (/.f64 z (*.f64 t a)) (/.f64 (/.f64 (*.f64 x (log.f64 y)) a) t))))
(/ t a)
(/.f64 t a)
(* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* x (log y)) a)) t)) (/ 1 a))))
(*.f64 (+.f64 (/.f64 (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)) (neg.f64 t)) (/.f64 #s(literal -1 binary64) a)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* x (log y)) a)) t)) (/ 1 a))))
(*.f64 (+.f64 (/.f64 (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)) (neg.f64 t)) (/.f64 #s(literal -1 binary64) a)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* x (log y)) a)) t)) (/ 1 a))))
(*.f64 (+.f64 (/.f64 (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)) (neg.f64 t)) (/.f64 #s(literal -1 binary64) a)) (neg.f64 t))
(/ (+ t (* x (log y))) a)
(/.f64 (+.f64 t (*.f64 x (log.f64 y))) a)
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+.f64 (/.f64 t a) (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)))
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+.f64 (/.f64 t a) (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)))
(+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))
(+.f64 (/.f64 t a) (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)))
(/ z a)
(/.f64 z a)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* x (log y)) (* a z)))))
(*.f64 z (+.f64 (/.f64 (/.f64 (*.f64 x (log.f64 y)) a) z) (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 t (*.f64 z a)))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* x (log y)) (* a z)))))
(*.f64 z (+.f64 (/.f64 (/.f64 (*.f64 x (log.f64 y)) a) z) (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 t (*.f64 z a)))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* x (log y)) (* a z)))))
(*.f64 z (+.f64 (/.f64 (/.f64 (*.f64 x (log.f64 y)) a) z) (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 t (*.f64 z a)))))
(/ z a)
(/.f64 z a)
(* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* x (log y)) a)) z)) (/ 1 a))))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 (/.f64 t a) (/.f64 (*.f64 x (log.f64 y)) a)) z)) (/.f64 #s(literal -1 binary64) a)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* x (log y)) a)) z)) (/ 1 a))))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 (/.f64 t a) (/.f64 (*.f64 x (log.f64 y)) a)) z)) (/.f64 #s(literal -1 binary64) a)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* x (log y)) a)) z)) (/ 1 a))))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 (/.f64 t a) (/.f64 (*.f64 x (log.f64 y)) a)) z)) (/.f64 #s(literal -1 binary64) a)) (neg.f64 z))
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(/ (+ t (+ z (* x (log y)))) a)
(/.f64 (+.f64 z (+.f64 t (*.f64 x (log.f64 y)))) a)
(log c)
(log.f64 c)
(log c)
(log.f64 c)
(log c)
(log.f64 c)
(log c)
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))

eval231.0ms (1.8%)

Compiler

Compiled 54499 to 2999 computations (94.5% saved)

prune208.0ms (1.6%)

Pruning

30 alts after pruning (28 fresh and 2 done)

PrunedKeptTotal
New1535161551
Fresh21214
Picked325
Done000
Total1540301570
Accuracy
100.0%
Counts
1570 → 30
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶8.7%
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
3.6%
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
8.7%
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
3.6%
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
50.6%
(+.f64 (/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 y i))
43.8%
(+.f64 (/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) a) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) a)) (*.f64 y i))
69.2%
(+.f64 (+.f64 (+.f64 (*.f64 a (/.f64 (*.f64 x (log.f64 y)) a)) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
▶82.5%
(+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
61.0%
(+.f64 (+.f64 (+.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
76.5%
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
42.4%
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (/.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 b #s(literal 1/2 binary64)))) (*.f64 y i))
61.5%
(+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
36.8%
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
33.1%
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
41.9%
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
79.9%
(+.f64 (*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (*.f64 x (/.f64 (log.f64 y) a)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) a))) (+.f64 (/.f64 t a) (/.f64 z a))))) (*.f64 y i))
✓47.2%
(+.f64 z (*.f64 y i))
45.6%
(+.f64 a (*.f64 y i))
3.6%
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
▶14.6%
(*.f64 (log.f64 c) b)
42.7%
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
▶46.4%
(*.f64 y (+.f64 (/.f64 a y) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) i)))
37.7%
(*.f64 y (+.f64 i (/.f64 z y)))
67.8%
(*.f64 y (+.f64 i (+.f64 (*.f64 (log.f64 y) (/.f64 x y)) (+.f64 (+.f64 (/.f64 z y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) (+.f64 (/.f64 a y) (/.f64 t y))))))
18.4%
(*.f64 x (log.f64 y))
36.0%
(*.f64 i (+.f64 y (/.f64 z i)))
45.4%
(*.f64 i (+.f64 y (+.f64 (/.f64 a i) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)))))
25.8%
(*.f64 i y)
▶23.7%
z
✓21.8%
a
Compiler

Compiled 1478 to 950 computations (35.7% saved)

simplify274.0ms (2.1%)

Algorithm
1×egg-herbie
Localize:

Found 14 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) i)
✓cost-diff0
(/.f64 a y)
✓cost-diff0
(+.f64 (/.f64 a y) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) i))
✓cost-diff256
(*.f64 y (+.f64 (/.f64 a y) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) i)))
✓cost-diff0
(log.f64 c)
✓cost-diff0
(*.f64 (log.f64 c) b)
✓cost-diff0
(*.f64 y (*.f64 i (*.f64 y i)))
✓cost-diff0
(*.f64 z z)
✓cost-diff0
(-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))
✓cost-diff768
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
✓cost-diff0
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
✓cost-diff0
(+.f64 z a)
✓cost-diff0
(+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
✓cost-diff0
(+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Rules
2064×*-lowering-*.f32
2064×*-lowering-*.f64
1608×+-lowering-+.f64
1608×+-lowering-+.f32
1500×--lowering--.f32
Iterations

Useful iterations: 4 (0.0ms)

IterNodesCost
029174
182161
2244158
3654151
41643145
54145145
67281145
08151145
Stop Event
1×iter limit
1×node limit
Calls
Call 1
Inputs
(+ (+ (+ z a) (* (- b 1/2) (log c))) (* y i))
(+ (+ z a) (* (- b 1/2) (log c)))
(+ z a)
z
a
(* (- b 1/2) (log c))
(- b 1/2)
b
1/2
(log c)
c
(* y i)
y
i
z
(/ (- (* z z) (* y (* i (* y i)))) (- z (* y i)))
(- (* z z) (* y (* i (* y i))))
(* z z)
z
(* y (* i (* y i)))
y
(* i (* y i))
i
(* y i)
(- z (* y i))
(* (log c) b)
(log c)
c
b
(* y (+ (/ a y) (+ (/ (* (log c) (+ b -1/2)) y) i)))
y
(+ (/ a y) (+ (/ (* (log c) (+ b -1/2)) y) i))
(/ a y)
a
(+ (/ (* (log c) (+ b -1/2)) y) i)
(/ (* (log c) (+ b -1/2)) y)
(* (log c) (+ b -1/2))
(log c)
c
(+ b -1/2)
b
-1/2
i
Outputs
(+ (+ (+ z a) (* (- b 1/2) (log c))) (* y i))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 a (+.f64 z (*.f64 y i))))
(+ (+ z a) (* (- b 1/2) (log c)))
(+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(+ z a)
(+.f64 z a)
z
a
(* (- b 1/2) (log c))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))
(- b 1/2)
(+.f64 b #s(literal -1/2 binary64))
b
1/2
#s(literal 1/2 binary64)
(log c)
(log.f64 c)
c
(* y i)
(*.f64 y i)
y
i
z
(/ (- (* z z) (* y (* i (* y i)))) (- z (* y i)))
(+.f64 z (*.f64 y i))
(- (* z z) (* y (* i (* y i))))
(-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))
(* z z)
(*.f64 z z)
z
(* y (* i (* y i)))
(*.f64 y (*.f64 i (*.f64 y i)))
y
(* i (* y i))
(*.f64 i (*.f64 y i))
i
(* y i)
(*.f64 y i)
(- z (* y i))
(-.f64 z (*.f64 y i))
(* (log c) b)
(*.f64 b (log.f64 c))
(log c)
(log.f64 c)
c
b
(* y (+ (/ a y) (+ (/ (* (log c) (+ b -1/2)) y) i)))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 a (*.f64 y i)))
y
(+ (/ a y) (+ (/ (* (log c) (+ b -1/2)) y) i))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))
(/ a y)
(/.f64 a y)
a
(+ (/ (* (log c) (+ b -1/2)) y) i)
(+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))
(/ (* (log c) (+ b -1/2)) y)
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))
(* (log c) (+ b -1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))
(log c)
(log.f64 c)
c
(+ b -1/2)
(+.f64 b #s(literal -1/2 binary64))
b
-1/2
#s(literal -1/2 binary64)
i

localize153.0ms (1.2%)

Localize:

Found 14 expressions of interest:

NewMetricScoreProgram
✓accuracy99.8%
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
✓accuracy99.6%
(/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y)
✓accuracy96.7%
(+.f64 (/.f64 a y) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) i))
✓accuracy79.8%
(*.f64 y (+.f64 (/.f64 a y) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) i)))
✓accuracy100.0%
(log.f64 c)
✓accuracy99.6%
(*.f64 (log.f64 c) b)
✓accuracy99.8%
(*.f64 i (*.f64 y i))
✓accuracy93.8%
(*.f64 y (*.f64 i (*.f64 y i)))
✓accuracy91.9%
(-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))
✓accuracy45.1%
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
✓accuracy100.0%
(log.f64 c)
✓accuracy100.0%
(+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
✓accuracy100.0%
(+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
✓accuracy99.8%
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
Results
116.0ms256×0valid
Compiler

Compiled 188 to 32 computations (83% saved)

Precisions
Click to see histograms. Total time spent on operations: 39.0ms
ival-mult: 14.0ms (35.8% of total)
ival-add: 10.0ms (25.5% of total)
ival-sub: 5.0ms (12.8% of total)
ival-div: 5.0ms (12.8% of total)
ival-log: 4.0ms (10.2% of total)
const: 1.0ms (2.6% of total)
backward-pass: 0.0ms (0% of total)

series55.0ms (0.4%)

Counts
17 → 588
Calls
Call 1
Inputs
#<alt (+ (+ (+ z a) (* (- b 1/2) (log c))) (* y i))>
#<alt (+ (+ z a) (* (- b 1/2) (log c)))>
#<alt (+ z a)>
#<alt (* (- b 1/2) (log c))>
#<alt (/ (- (* z z) (* y (* i (* y i)))) (- z (* y i)))>
#<alt (- (* z z) (* y (* i (* y i))))>
#<alt (* z z)>
#<alt (* y (* i (* y i)))>
#<alt (* (log c) b)>
#<alt (log c)>
#<alt (* y (+ (/ a y) (+ (/ (* (log c) (+ b -1/2)) y) i)))>
#<alt (+ (/ a y) (+ (/ (* (log c) (+ b -1/2)) y) i))>
#<alt (/ a y)>
#<alt (+ (/ (* (log c) (+ b -1/2)) y) i)>
#<alt (* i (* y i))>
#<alt (/ (* (log c) (+ b -1/2)) y)>
#<alt (* (log c) (+ b -1/2))>
Outputs
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt z>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) z)) 1)))>
#<alt (+ z (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt a>
#<alt (* a (+ 1 (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))>
#<alt (* a (+ 1 (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))>
#<alt (* a (+ 1 (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (+ z (+ (* i y) (* (log c) (- b 1/2)))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ z (+ (* i y) (* (log c) (- b 1/2)))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ z (+ (* i y) (* (log c) (- b 1/2)))) a)) 1)))>
#<alt (+ a (+ z (+ (* -1/2 (log c)) (* i y))))>
#<alt (+ a (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))>
#<alt (+ a (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))>
#<alt (+ a (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ z b) (/ (* i y) b))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ z b) (/ (* i y) b))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ z b) (/ (* i y) b))))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (+ (* -1/2 (log c)) (* i y)))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (+ (* -1/2 (log c)) (* i y)))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (+ (* -1/2 (log c)) (* i y)))) b)))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))>
#<alt (+ a (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))>
#<alt (+ a (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))>
#<alt (+ a (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))>
#<alt (+ a (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (* i y)>
#<alt (* y (+ i (+ (/ a y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))>
#<alt (* y (+ i (+ (/ a y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))>
#<alt (* y (+ i (+ (/ a y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))>
#<alt (* i y)>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) y)))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))>
#<alt (* i y)>
#<alt (* i (+ y (+ (/ a i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))>
#<alt (* i (+ y (+ (/ a i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))>
#<alt (* i (+ y (+ (/ a i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))>
#<alt (* i y)>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) i)))))>
#<alt (+ a (* (log c) (- b 1/2)))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt z>
#<alt (* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))>
#<alt (* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))>
#<alt (* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))>
#<alt (+ z (* (log c) (- b 1/2)))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt a>
#<alt (* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))>
#<alt (* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))>
#<alt (* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))>
#<alt (+ a (+ z (* -1/2 (log c))))>
#<alt (+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))>
#<alt (+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))>
#<alt (+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))>
#<alt (+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))>
#<alt (+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))>
#<alt (+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))>
#<alt (+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt a>
#<alt (+ a z)>
#<alt (+ a z)>
#<alt (+ a z)>
#<alt z>
#<alt (* z (+ 1 (/ a z)))>
#<alt (* z (+ 1 (/ a z)))>
#<alt (* z (+ 1 (/ a z)))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ a z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ a z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ a z)) 1)))>
#<alt z>
#<alt (+ a z)>
#<alt (+ a z)>
#<alt (+ a z)>
#<alt a>
#<alt (* a (+ 1 (/ z a)))>
#<alt (* a (+ 1 (/ z a)))>
#<alt (* a (+ 1 (/ z a)))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ z a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ z a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ z a)) 1)))>
#<alt (* -1/2 (log c))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* i y)>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt z>
#<alt (* z (+ 1 (/ (* i y) z)))>
#<alt (* z (+ 1 (/ (* i y) z)))>
#<alt (* z (+ 1 (/ (* i y) z)))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (* i y) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (* i y) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (* i y) z)) 1)))>
#<alt z>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt (* i y)>
#<alt (* y (+ i (/ z y)))>
#<alt (* y (+ i (/ z y)))>
#<alt (* y (+ i (/ z y)))>
#<alt (* i y)>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))>
#<alt z>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt (* i y)>
#<alt (* i (+ y (/ z i)))>
#<alt (* i (+ y (/ z i)))>
#<alt (* i (+ y (/ z i)))>
#<alt (* i y)>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))>
#<alt (* -1 (* (pow i 2) (pow y 2)))>
#<alt (- (pow z 2) (* (pow i 2) (pow y 2)))>
#<alt (- (pow z 2) (* (pow i 2) (pow y 2)))>
#<alt (- (pow z 2) (* (pow i 2) (pow y 2)))>
#<alt (pow z 2)>
#<alt (* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))>
#<alt (* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))>
#<alt (* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))>
#<alt (pow z 2)>
#<alt (* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))>
#<alt (* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))>
#<alt (* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))>
#<alt (pow z 2)>
#<alt (+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))>
#<alt (+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))>
#<alt (+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))>
#<alt (* -1 (* (pow i 2) (pow y 2)))>
#<alt (* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))>
#<alt (* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))>
#<alt (* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))>
#<alt (* -1 (* (pow i 2) (pow y 2)))>
#<alt (* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))>
#<alt (* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))>
#<alt (* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))>
#<alt (pow z 2)>
#<alt (+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))>
#<alt (+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))>
#<alt (+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))>
#<alt (* -1 (* (pow i 2) (pow y 2)))>
#<alt (* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))>
#<alt (* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))>
#<alt (* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))>
#<alt (* -1 (* (pow i 2) (pow y 2)))>
#<alt (* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))>
#<alt (* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))>
#<alt (* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (* -1 (* b (log (/ 1 c))))>
#<alt (* -1 (* b (log (/ 1 c))))>
#<alt (* -1 (* b (log (/ 1 c))))>
#<alt (* -1 (* b (log (/ 1 c))))>
#<alt (* b (+ (log -1) (* -1 (log (/ -1 c)))))>
#<alt (* b (+ (log -1) (* -1 (log (/ -1 c)))))>
#<alt (* b (+ (log -1) (* -1 (log (/ -1 c)))))>
#<alt (* b (+ (log -1) (* -1 (log (/ -1 c)))))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (* b (log c))>
#<alt (log c)>
#<alt (log c)>
#<alt (log c)>
#<alt (log c)>
#<alt (* -1 (log (/ 1 c)))>
#<alt (* -1 (log (/ 1 c)))>
#<alt (* -1 (log (/ 1 c)))>
#<alt (* -1 (log (/ 1 c)))>
#<alt (+ (log -1) (* -1 (log (/ -1 c))))>
#<alt (+ (log -1) (* -1 (log (/ -1 c))))>
#<alt (+ (log -1) (* -1 (log (/ -1 c))))>
#<alt (+ (log -1) (* -1 (log (/ -1 c))))>
#<alt (+ a (* (log c) (- b 1/2)))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (+ a (+ (* i y) (* (log c) (- b 1/2))))>
#<alt (* i y)>
#<alt (* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* i y)>
#<alt (* -1 (* y (+ (* -1 i) (+ (* -1 (/ a y)) (* -1 (/ (* (log c) (- b 1/2)) y))))))>
#<alt (* -1 (* y (+ (* -1 i) (+ (* -1 (/ a y)) (* -1 (/ (* (log c) (- b 1/2)) y))))))>
#<alt (* -1 (* y (+ (* -1 i) (+ (* -1 (/ a y)) (* -1 (/ (* (log c) (- b 1/2)) y))))))>
#<alt (* y (+ i (/ (* (log c) (- b 1/2)) y)))>
#<alt (+ a (* y (+ i (/ (* (log c) (- b 1/2)) y))))>
#<alt (+ a (* y (+ i (/ (* (log c) (- b 1/2)) y))))>
#<alt (+ a (* y (+ i (/ (* (log c) (- b 1/2)) y))))>
#<alt a>
#<alt (* a (+ 1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)))>
#<alt (* a (+ 1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)))>
#<alt (* a (+ 1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)) 1)))>
#<alt (* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y))))>
#<alt (* y (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y))))>
#<alt (* y (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y))))>
#<alt (* y (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y))))>
#<alt (* y (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))))>
#<alt (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y))))>
#<alt (+ (* b (log c)) (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))))>
#<alt (+ (* b (log c)) (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))))>
#<alt (+ (* b (log c)) (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))>
#<alt (* b (+ (log c) (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))>
#<alt (* b (+ (log c) (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))))>
#<alt (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt (+ (* i y) (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))>
#<alt (+ (* i y) (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))>
#<alt (+ (* i y) (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))>
#<alt (* i y)>
#<alt (* i (+ y (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))>
#<alt (* i (+ y (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))>
#<alt (* i (+ y (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))>
#<alt (* i y)>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))))>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt (/ a y)>
#<alt (* a (+ (/ 1 y) (+ (/ i a) (/ (* (log c) (- b 1/2)) (* a y)))))>
#<alt (* a (+ (/ 1 y) (+ (/ i a) (/ (* (log c) (- b 1/2)) (* a y)))))>
#<alt (* a (+ (/ 1 y) (+ (/ i a) (/ (* (log c) (- b 1/2)) (* a y)))))>
#<alt (/ a y)>
#<alt (* -1 (* a (- (* -1 (/ (+ i (/ (* (log c) (- b 1/2)) y)) a)) (/ 1 y))))>
#<alt (* -1 (* a (- (* -1 (/ (+ i (/ (* (log c) (- b 1/2)) y)) a)) (/ 1 y))))>
#<alt (* -1 (* a (- (* -1 (/ (+ i (/ (* (log c) (- b 1/2)) y)) a)) (/ 1 y))))>
#<alt (/ (+ a (* (log c) (- b 1/2))) y)>
#<alt (/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) y)>
#<alt (/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) y)>
#<alt (/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) y)>
#<alt i>
#<alt (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt i>
#<alt (+ i (* -1 (/ (+ (* -1 a) (* -1 (* (log c) (- b 1/2)))) y)))>
#<alt (+ i (* -1 (/ (+ (* -1 a) (* -1 (* (log c) (- b 1/2)))) y)))>
#<alt (+ i (* -1 (/ (+ (* -1 a) (* -1 (* (log c) (- b 1/2)))) y)))>
#<alt (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y)))>
#<alt (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y)))>
#<alt (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y)))>
#<alt (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y)))>
#<alt (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)))>
#<alt (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)))>
#<alt (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)))>
#<alt (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)))>
#<alt (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))>
#<alt (+ i (+ (* -1/2 (/ (log c) y)) (+ (/ a y) (/ (* b (log c)) y))))>
#<alt (+ i (+ (* -1/2 (/ (log c) y)) (+ (/ a y) (/ (* b (log c)) y))))>
#<alt (+ i (+ (* -1/2 (/ (log c) y)) (+ (/ a y) (/ (* b (log c)) y))))>
#<alt (/ (* b (log c)) y)>
#<alt (* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ a (* b y)) (+ (/ i b) (/ (log c) y)))))>
#<alt (* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ a (* b y)) (+ (/ i b) (/ (log c) y)))))>
#<alt (* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ a (* b y)) (+ (/ i b) (/ (log c) y)))))>
#<alt (/ (* b (log c)) y)>
#<alt (* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (+ (* -1/2 (/ (log c) y)) (/ a y))) b)))))>
#<alt (* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (+ (* -1/2 (/ (log c) y)) (/ a y))) b)))))>
#<alt (* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (+ (* -1/2 (/ (log c) y)) (/ a y))) b)))))>
#<alt (+ (/ a y) (/ (* (log c) (- b 1/2)) y))>
#<alt (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))>
#<alt i>
#<alt (* i (+ 1 (+ (/ a (* i y)) (/ (* (log c) (- b 1/2)) (* i y)))))>
#<alt (* i (+ 1 (+ (/ a (* i y)) (/ (* (log c) (- b 1/2)) (* i y)))))>
#<alt (* i (+ 1 (+ (/ a (* i y)) (/ (* (log c) (- b 1/2)) (* i y)))))>
#<alt i>
#<alt (* -1 (* i (- (* -1 (/ (+ (/ a y) (/ (* (log c) (- b 1/2)) y)) i)) 1)))>
#<alt (* -1 (* i (- (* -1 (/ (+ (/ a y) (/ (* (log c) (- b 1/2)) y)) i)) 1)))>
#<alt (* -1 (* i (- (* -1 (/ (+ (/ a y) (/ (* (log c) (- b 1/2)) y)) i)) 1)))>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (/ a y)>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt (+ i (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)))>
#<alt (+ i (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)))>
#<alt (+ i (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)))>
#<alt (+ i (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)))>
#<alt (+ i (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))>
#<alt (+ i (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))>
#<alt (+ i (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))>
#<alt (+ i (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))>
#<alt (+ i (* -1/2 (/ (log c) y)))>
#<alt (+ i (+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y)))>
#<alt (+ i (+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y)))>
#<alt (+ i (+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y)))>
#<alt (/ (* b (log c)) y)>
#<alt (* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ i b) (/ (log c) y))))>
#<alt (* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ i b) (/ (log c) y))))>
#<alt (* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ i b) (/ (log c) y))))>
#<alt (/ (* b (log c)) y)>
#<alt (* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (* -1/2 (/ (log c) y))) b)))))>
#<alt (* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (* -1/2 (/ (log c) y))) b)))))>
#<alt (* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (* -1/2 (/ (log c) y))) b)))))>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (+ (* i y) (* (log c) (- b 1/2))) y)>
#<alt (/ (+ (* i y) (* (log c) (- b 1/2))) y)>
#<alt (/ (+ (* i y) (* (log c) (- b 1/2))) y)>
#<alt i>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt i>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt (+ i (/ (* (log c) (- b 1/2)) y))>
#<alt i>
#<alt (* i (+ 1 (/ (* (log c) (- b 1/2)) (* i y))))>
#<alt (* i (+ 1 (/ (* (log c) (- b 1/2)) (* i y))))>
#<alt (* i (+ 1 (/ (* (log c) (- b 1/2)) (* i y))))>
#<alt i>
#<alt (* -1 (* i (- (* -1 (/ (* (log c) (- b 1/2)) (* i y))) 1)))>
#<alt (* -1 (* i (- (* -1 (/ (* (log c) (- b 1/2)) (* i y))) 1)))>
#<alt (* -1 (* i (- (* -1 (/ (* (log c) (- b 1/2)) (* i y))) 1)))>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (* (pow i 2) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y))>
#<alt (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y))>
#<alt (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y))>
#<alt (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y))>
#<alt (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)>
#<alt (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)>
#<alt (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)>
#<alt (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)>
#<alt (* -1/2 (/ (log c) y))>
#<alt (+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y))>
#<alt (+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y))>
#<alt (+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y))>
#<alt (/ (* b (log c)) y)>
#<alt (* b (+ (* -1/2 (/ (log c) (* b y))) (/ (log c) y)))>
#<alt (* b (+ (* -1/2 (/ (log c) (* b y))) (/ (log c) y)))>
#<alt (* b (+ (* -1/2 (/ (log c) (* b y))) (/ (log c) y)))>
#<alt (/ (* b (log c)) y)>
#<alt (* -1 (* b (+ (* -1 (/ (log c) y)) (* 1/2 (/ (log c) (* b y))))))>
#<alt (* -1 (* b (+ (* -1 (/ (log c) y)) (* 1/2 (/ (log c) (* b y))))))>
#<alt (* -1 (* b (+ (* -1 (/ (log c) y)) (* 1/2 (/ (log c) (* b y))))))>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (/ (* (log c) (- b 1/2)) y)>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* -1/2 (log c))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
Calls

147 calls:

TimeVariablePointExpression
10.0ms
i
@0
(/ (- (* z z) (* y (* i (* y i)))) (- z (* y i)))
9.0ms
b
@0
(* (log c) b)
2.0ms
c
@0
(* y (+ (/ a y) (+ (/ (* (log c) (+ b -1/2)) y) i)))
2.0ms
y
@inf
(/ (* (log c) (+ b -1/2)) y)
1.0ms
z
@0
(/ (- (* z z) (* y (* i (* y i)))) (- z (* y i)))

rewrite553.0ms (4.3%)

Algorithm
1×batch-egg-rewrite
Rules
6024×*-lowering-*.f32
6024×*-lowering-*.f64
3394×+-lowering-+.f64
3394×+-lowering-+.f32
3160×/-lowering-/.f32
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
029134
1220112
22226107
011555107
Stop Event
1×iter limit
1×node limit
Counts
17 → 735
Calls
Call 1
Inputs
(+ (+ (+ z a) (* (- b 1/2) (log c))) (* y i))
(+ (+ z a) (* (- b 1/2) (log c)))
(+ z a)
(* (- b 1/2) (log c))
(/ (- (* z z) (* y (* i (* y i)))) (- z (* y i)))
(- (* z z) (* y (* i (* y i))))
(* z z)
(* y (* i (* y i)))
(* (log c) b)
(log c)
(* y (+ (/ a y) (+ (/ (* (log c) (+ b -1/2)) y) i)))
(+ (/ a y) (+ (/ (* (log c) (+ b -1/2)) y) i))
(/ a y)
(+ (/ (* (log c) (+ b -1/2)) y) i)
(* i (* y i))
(/ (* (log c) (+ b -1/2)) y)
(* (log c) (+ b -1/2))
Outputs
(+.f64 z (+.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(+.f64 z (+.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i)))
(+.f64 a (+.f64 z (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(+.f64 (+.f64 z a) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 (+.f64 z a) (*.f64 y i)))
(+.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (*.f64 y i) (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 (+.f64 z (*.f64 y i)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 z a))
(+.f64 (+.f64 (*.f64 y i) (+.f64 z a)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(-.f64 (/.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (-.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i))))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c) (+.f64 (+.f64 z a) (*.f64 y i)))
(fma.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 z a) (*.f64 y i)))
(fma.f64 y i (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 i y (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i)))) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(fma.f64 (+.f64 (*.f64 (+.f64 z a) (*.f64 (+.f64 z a) (+.f64 z a))) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 z a))))) (*.f64 y i))
(fma.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (-.f64 z a)) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))
(fma.f64 (-.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 y i))
(fma.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (+.f64 z (*.f64 y i)) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(fma.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i)) (-.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))))
(/.f64 (-.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i)))
(/.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (neg.f64 (+.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))) (neg.f64 (-.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (+.f64 z a) (*.f64 (+.f64 z a) (+.f64 z a))) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64)) (*.f64 (+.f64 z a) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (-.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (pow.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 2 binary64))) (-.f64 (+.f64 z a) (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))) (-.f64 (*.f64 y i) (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (-.f64 z a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (-.f64 z a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (-.f64 z a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (neg.f64 (-.f64 z a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (neg.f64 (-.f64 z a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (neg.f64 (-.f64 z a)) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (neg.f64 (-.f64 z a)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))) (*.f64 (-.f64 a z) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (*.f64 (-.f64 a z) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))) (*.f64 (-.f64 a z) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 a z) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (-.f64 z (*.f64 y i)) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))) #s(literal 1 binary64)) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))) #s(literal 1 binary64)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))) #s(literal 1 binary64)) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))) #s(literal 1 binary64)) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i)))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i)))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (*.f64 z z) (-.f64 z (*.f64 y i))) (*.f64 (-.f64 z (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (*.f64 (-.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (*.f64 (-.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (*.f64 z z) (-.f64 z (*.f64 y i))) (*.f64 (-.f64 z (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (*.f64 (-.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (*.f64 (-.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) #s(literal 1 binary64)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))) (-.f64 z (*.f64 y i))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))) (-.f64 z (*.f64 y i))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) #s(literal 1 binary64)) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))) (-.f64 z (*.f64 y i))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) #s(literal 1 binary64)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (*.f64 (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (*.f64 (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) #s(literal 1 binary64)) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (*.f64 (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (*.f64 (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i)))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i)))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 z (*.f64 y i)))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 z (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 z (*.f64 y i)))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 z (*.f64 y i)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))))) (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (+.f64 (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 z (/.f64 z (-.f64 z (*.f64 y i))))) (+.f64 (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))) (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 z (/.f64 z (-.f64 z (*.f64 y i))))) (+.f64 (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))) (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))))) (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 z (/.f64 z (-.f64 z (*.f64 y i))))) (+.f64 (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))) (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 z (/.f64 z (-.f64 z (*.f64 y i))))) (+.f64 (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))) (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 z (/.f64 z (-.f64 z (*.f64 y i))))) (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (+.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 z (/.f64 z (-.f64 z (*.f64 y i))))) (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (*.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) #s(literal 1 binary64)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) #s(literal 1 binary64)) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (-.f64 z (*.f64 y i)) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (neg.f64 (-.f64 z a))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (neg.f64 (-.f64 z a))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 a z)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)))) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (neg.f64 (-.f64 z a))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (neg.f64 (-.f64 z a))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 a z)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (*.f64 y i)) (-.f64 a z)))
(pow.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))) (+.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i)) (-.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i))))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))))
(*.f64 (-.f64 (pow.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 y (*.f64 i (*.f64 y i)))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (*.f64 y i))))
(+.f64 z (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 a (+.f64 z (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(+.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 z a))
(+.f64 (*.f64 b (log.f64 c)) (+.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (+.f64 z a)))
(+.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) z)
(+.f64 (+.f64 (+.f64 z a) (*.f64 b (log.f64 c))) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(+.f64 (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) z) a)
(-.f64 (/.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (-.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (/.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(fma.f64 b (log.f64 c) (+.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (+.f64 z a)))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c) (+.f64 z a))
(fma.f64 (log.f64 c) b (+.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (+.f64 z a)))
(fma.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)) (+.f64 z a))
(fma.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(fma.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (-.f64 z a)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(/.f64 (+.f64 (*.f64 (+.f64 z a) (*.f64 (+.f64 z a) (+.f64 z a))) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 z a)))))
(/.f64 (+.f64 (*.f64 (+.f64 z a) (*.f64 (+.f64 z a) (+.f64 z a))) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (*.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 z a)))) (+.f64 (*.f64 (+.f64 z a) (*.f64 (+.f64 z a) (+.f64 z a))) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (-.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 z a) (*.f64 (+.f64 z a) (+.f64 z a))) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 z a))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (+.f64 (*.f64 z (*.f64 z z)) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 3 binary64))) (+.f64 (*.f64 z z) (-.f64 (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64)) (*.f64 z (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))))
(/.f64 (-.f64 (*.f64 z z) (pow.f64 (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal 2 binary64))) (-.f64 z (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 (+.f64 z a) (+.f64 z a))) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 z a)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (-.f64 z a) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (-.f64 z a) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (-.f64 z a) (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (-.f64 z a) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (-.f64 z a) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 z a) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (-.f64 z a) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 z a) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 z a) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (-.f64 z a) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (-.f64 z a) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (-.f64 z a) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (-.f64 z a) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (-.f64 z a) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 z a) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (-.f64 z a) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (neg.f64 (-.f64 z a)) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (-.f64 z a)) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (neg.f64 (-.f64 z a)) (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (-.f64 z a)) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (neg.f64 (-.f64 z a)) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (-.f64 z a)) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (neg.f64 (-.f64 z a)) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (-.f64 z a)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (-.f64 z a)) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (neg.f64 (-.f64 z a)) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (neg.f64 (-.f64 z a)) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (-.f64 z a)) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (neg.f64 (-.f64 z a)) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (-.f64 z a)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (-.f64 z a)) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (-.f64 z a)) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (-.f64 a z) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (-.f64 a z) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (-.f64 a z) (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (-.f64 a z) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (-.f64 a z) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 a z) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (-.f64 a z) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 a z) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 a z) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (-.f64 a z) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (-.f64 a z) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (-.f64 a z) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))) (*.f64 (-.f64 a z) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (-.f64 a z) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 a z) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (-.f64 a z) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (-.f64 z a)) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (neg.f64 (-.f64 z a))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (neg.f64 (-.f64 z a))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (-.f64 a z)) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (-.f64 z a)) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (neg.f64 (-.f64 z a))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 (-.f64 z a))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (-.f64 a z)) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) #s(literal 1 binary64))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) #s(literal 1 binary64))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 z a)) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (-.f64 z a))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (neg.f64 (-.f64 z a))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 a z)) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 z a)) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (-.f64 z a))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (-.f64 z a))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 a z)) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (-.f64 z a)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (neg.f64 (-.f64 z a))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 z a))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (-.f64 a z)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) #s(literal 1 binary64))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) #s(literal 1 binary64))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 z a)) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (neg.f64 (-.f64 z a))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (neg.f64 (-.f64 z a))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 a z)) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 z a)) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (neg.f64 (-.f64 z a))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (neg.f64 (-.f64 z a))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 a z)) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (-.f64 z a)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (neg.f64 (-.f64 z a))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 z a))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (-.f64 a z)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 a z)))
(pow.f64 (/.f64 (+.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 z a)))) (+.f64 (*.f64 (+.f64 z a) (*.f64 (+.f64 z a) (+.f64 z a))) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 (+.f64 z a) (*.f64 (+.f64 z a) (+.f64 z a))) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 z a))))))
(*.f64 (-.f64 (*.f64 (+.f64 z a) (+.f64 z a)) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 z a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(+.f64 z a)
(+.f64 a z)
(-.f64 (/.f64 (*.f64 z z) (-.f64 z a)) (/.f64 (*.f64 a a) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))))
(/.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 a a) (-.f64 (*.f64 z z) (*.f64 z a))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))))
(/.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (-.f64 z a))
(/.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))))
(/.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 a a))) (neg.f64 (-.f64 z a)))
(/.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (-.f64 a z))
(pow.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 z a) (-.f64 (*.f64 z z) (*.f64 a a))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 a (-.f64 a z)))))
(*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (-.f64 z a)))
(+.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(+.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 b (log.f64 c)))
(fma.f64 b (log.f64 c) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(fma.f64 (log.f64 c) b (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(fma.f64 (log.f64 c) #s(literal -1/2 binary64) (*.f64 b (log.f64 c)))
(fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 b (log.f64 c)))
(/.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))
(/.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))))
(/.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 b #s(literal 1/2 binary64)))
(/.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))))
(/.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 b #s(literal 1/2 binary64)))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+.f64 z (*.f64 y i))
(+.f64 (*.f64 y i) z)
(+.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (neg.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))
(+.f64 (fma.f64 z (/.f64 z (-.f64 z (*.f64 y i))) (neg.f64 (*.f64 (/.f64 (*.f64 i (*.f64 y i)) (-.f64 z (*.f64 y i))) y))) (fma.f64 (neg.f64 (/.f64 (*.f64 i (*.f64 y i)) (-.f64 z (*.f64 y i)))) y (*.f64 (/.f64 (*.f64 i (*.f64 y i)) (-.f64 z (*.f64 y i))) y)))
(+.f64 (fma.f64 z (/.f64 z (-.f64 z (*.f64 y i))) (neg.f64 (*.f64 (/.f64 (*.f64 y i) (-.f64 z (*.f64 y i))) (*.f64 y i)))) (fma.f64 (neg.f64 (/.f64 (*.f64 y i) (-.f64 z (*.f64 y i)))) (*.f64 y i) (*.f64 (/.f64 (*.f64 y i) (-.f64 z (*.f64 y i))) (*.f64 y i))))
(+.f64 (fma.f64 z (/.f64 z (-.f64 z (*.f64 y i))) (neg.f64 (*.f64 (/.f64 y (-.f64 z (*.f64 y i))) (*.f64 i (*.f64 y i))))) (fma.f64 (neg.f64 (/.f64 y (-.f64 z (*.f64 y i)))) (*.f64 i (*.f64 y i)) (*.f64 (/.f64 y (-.f64 z (*.f64 y i))) (*.f64 i (*.f64 y i)))))
(+.f64 (fma.f64 z (/.f64 z (-.f64 z (*.f64 y i))) (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))))) (fma.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i)))) (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))
(+.f64 (fma.f64 z (/.f64 z (-.f64 z (*.f64 y i))) (neg.f64 (*.f64 (+.f64 z (*.f64 y i)) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))))))) (fma.f64 (neg.f64 (+.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))))))
(+.f64 (fma.f64 z (/.f64 z (-.f64 z (*.f64 y i))) (neg.f64 (*.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))))) (fma.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i))))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))))))
(+.f64 (fma.f64 (*.f64 z z) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (neg.f64 (*.f64 (/.f64 (*.f64 i (*.f64 y i)) (-.f64 z (*.f64 y i))) y))) (fma.f64 (neg.f64 (/.f64 (*.f64 i (*.f64 y i)) (-.f64 z (*.f64 y i)))) y (*.f64 (/.f64 (*.f64 i (*.f64 y i)) (-.f64 z (*.f64 y i))) y)))
(+.f64 (fma.f64 (*.f64 z z) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (neg.f64 (*.f64 (/.f64 (*.f64 y i) (-.f64 z (*.f64 y i))) (*.f64 y i)))) (fma.f64 (neg.f64 (/.f64 (*.f64 y i) (-.f64 z (*.f64 y i)))) (*.f64 y i) (*.f64 (/.f64 (*.f64 y i) (-.f64 z (*.f64 y i))) (*.f64 y i))))
(+.f64 (fma.f64 (*.f64 z z) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (neg.f64 (*.f64 (/.f64 y (-.f64 z (*.f64 y i))) (*.f64 i (*.f64 y i))))) (fma.f64 (neg.f64 (/.f64 y (-.f64 z (*.f64 y i)))) (*.f64 i (*.f64 y i)) (*.f64 (/.f64 y (-.f64 z (*.f64 y i))) (*.f64 i (*.f64 y i)))))
(+.f64 (fma.f64 (*.f64 z z) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))))) (fma.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i)))) (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))
(+.f64 (fma.f64 (*.f64 z z) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (neg.f64 (*.f64 (+.f64 z (*.f64 y i)) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))))))) (fma.f64 (neg.f64 (+.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))))))
(+.f64 (fma.f64 (*.f64 z z) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (neg.f64 (*.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))))) (fma.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i))))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))))))
(+.f64 (fma.f64 (/.f64 (*.f64 z z) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (+.f64 z (*.f64 y i)) (neg.f64 (*.f64 (/.f64 (*.f64 i (*.f64 y i)) (-.f64 z (*.f64 y i))) y))) (fma.f64 (neg.f64 (/.f64 (*.f64 i (*.f64 y i)) (-.f64 z (*.f64 y i)))) y (*.f64 (/.f64 (*.f64 i (*.f64 y i)) (-.f64 z (*.f64 y i))) y)))
(+.f64 (fma.f64 (/.f64 (*.f64 z z) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (+.f64 z (*.f64 y i)) (neg.f64 (*.f64 (/.f64 (*.f64 y i) (-.f64 z (*.f64 y i))) (*.f64 y i)))) (fma.f64 (neg.f64 (/.f64 (*.f64 y i) (-.f64 z (*.f64 y i)))) (*.f64 y i) (*.f64 (/.f64 (*.f64 y i) (-.f64 z (*.f64 y i))) (*.f64 y i))))
(+.f64 (fma.f64 (/.f64 (*.f64 z z) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (+.f64 z (*.f64 y i)) (neg.f64 (*.f64 (/.f64 y (-.f64 z (*.f64 y i))) (*.f64 i (*.f64 y i))))) (fma.f64 (neg.f64 (/.f64 y (-.f64 z (*.f64 y i)))) (*.f64 i (*.f64 y i)) (*.f64 (/.f64 y (-.f64 z (*.f64 y i))) (*.f64 i (*.f64 y i)))))
(+.f64 (fma.f64 (/.f64 (*.f64 z z) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (+.f64 z (*.f64 y i)) (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))))) (fma.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i)))) (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))
(+.f64 (fma.f64 (/.f64 (*.f64 z z) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (+.f64 z (*.f64 y i)) (neg.f64 (*.f64 (+.f64 z (*.f64 y i)) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))))))) (fma.f64 (neg.f64 (+.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))))))
(+.f64 (fma.f64 (/.f64 (*.f64 z z) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (+.f64 z (*.f64 y i)) (neg.f64 (*.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))))) (fma.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i))))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))))))
(+.f64 (fma.f64 (/.f64 (*.f64 z z) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (neg.f64 (*.f64 (/.f64 (*.f64 i (*.f64 y i)) (-.f64 z (*.f64 y i))) y))) (fma.f64 (neg.f64 (/.f64 (*.f64 i (*.f64 y i)) (-.f64 z (*.f64 y i)))) y (*.f64 (/.f64 (*.f64 i (*.f64 y i)) (-.f64 z (*.f64 y i))) y)))
(+.f64 (fma.f64 (/.f64 (*.f64 z z) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (neg.f64 (*.f64 (/.f64 (*.f64 y i) (-.f64 z (*.f64 y i))) (*.f64 y i)))) (fma.f64 (neg.f64 (/.f64 (*.f64 y i) (-.f64 z (*.f64 y i)))) (*.f64 y i) (*.f64 (/.f64 (*.f64 y i) (-.f64 z (*.f64 y i))) (*.f64 y i))))
(+.f64 (fma.f64 (/.f64 (*.f64 z z) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (neg.f64 (*.f64 (/.f64 y (-.f64 z (*.f64 y i))) (*.f64 i (*.f64 y i))))) (fma.f64 (neg.f64 (/.f64 y (-.f64 z (*.f64 y i)))) (*.f64 i (*.f64 y i)) (*.f64 (/.f64 y (-.f64 z (*.f64 y i))) (*.f64 i (*.f64 y i)))))
(+.f64 (fma.f64 (/.f64 (*.f64 z z) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))))) (fma.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i)))) (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))
(+.f64 (fma.f64 (/.f64 (*.f64 z z) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (neg.f64 (*.f64 (+.f64 z (*.f64 y i)) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))))))) (fma.f64 (neg.f64 (+.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))))))
(+.f64 (fma.f64 (/.f64 (*.f64 z z) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (neg.f64 (*.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))))) (fma.f64 (neg.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i))))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))))))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i)))) #s(literal -1 binary64)))
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(fma.f64 z (/.f64 z (-.f64 z (*.f64 y i))) (neg.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))
(fma.f64 y i z)
(fma.f64 i y z)
(fma.f64 (*.f64 z z) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (neg.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))
(fma.f64 (/.f64 (*.f64 z z) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (+.f64 z (*.f64 y i)) (neg.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))
(fma.f64 (/.f64 (*.f64 z z) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (neg.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))
(neg.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i)))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i))))
(/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))) #s(literal 1 binary64)))
(/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (-.f64 z (*.f64 y i))) (*.f64 (-.f64 z (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i))))) (*.f64 (-.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) #s(literal 1 binary64)) (*.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))) (-.f64 z (*.f64 y i))))
(/.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) #s(literal 1 binary64)) (*.f64 (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))))) (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i)))))
(/.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 z z) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))))) (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))) (+.f64 (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 z (/.f64 z (-.f64 z (*.f64 y i))))) (+.f64 (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))) (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))))
(/.f64 (-.f64 (*.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (*.f64 z (/.f64 z (-.f64 z (*.f64 y i))))) (*.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))) (+.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i)))))
(/.f64 (*.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) #s(literal 1 binary64)) (-.f64 z (*.f64 y i)))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i)))) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))))
(/.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i)))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))
(/.f64 (-.f64 (neg.f64 (*.f64 z z)) (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i)))) (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i)))))
(*.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i)))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (+.f64 z (*.f64 y i)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(*.f64 (pow.f64 (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 (pow.f64 (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))))
(+.f64 (*.f64 z z) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))
(+.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))))
(+.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))
(+.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (fma.f64 (neg.f64 (*.f64 y (*.f64 y i))) i (*.f64 y (*.f64 i (*.f64 y i)))))
(+.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (fma.f64 (neg.f64 (*.f64 (*.f64 y i) y)) i (*.f64 y (*.f64 i (*.f64 y i)))))
(+.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (fma.f64 (neg.f64 (*.f64 y y)) (*.f64 i i) (*.f64 y (*.f64 i (*.f64 y i)))))
(+.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (fma.f64 (neg.f64 (*.f64 i i)) (*.f64 y y) (*.f64 y (*.f64 i (*.f64 y i)))))
(+.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (fma.f64 (neg.f64 i) (*.f64 y (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))
(+.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (fma.f64 (neg.f64 i) (*.f64 (*.f64 y i) y) (*.f64 y (*.f64 i (*.f64 y i)))))
(+.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (fma.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 y i))) (-.f64 #s(literal 0 binary64) (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))
(+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))))
(+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 z z))
(-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))
(-.f64 (*.f64 z z) (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))
(-.f64 (/.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))) (/.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(-.f64 (/.f64 (*.f64 z (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (/.f64 (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(fma.f64 z z (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))))
(fma.f64 z z (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))
(fma.f64 z z (neg.f64 (-.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))))))
(fma.f64 y (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 y i))) (*.f64 z z))
(fma.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i)) (*.f64 z z))
(fma.f64 (*.f64 i (*.f64 y i)) (-.f64 #s(literal 0 binary64) y) (*.f64 z z))
(fma.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 y i))) y (*.f64 z z))
(fma.f64 (-.f64 #s(literal 0 binary64) y) (*.f64 i (*.f64 y i)) (*.f64 z z))
(fma.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))))
(fma.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))) (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))
(fma.f64 (-.f64 #s(literal 0 binary64) (*.f64 y i)) (*.f64 y i) (*.f64 z z))
(fma.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))))
(fma.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))
(fma.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))))
(fma.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)) (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))
(fma.f64 #s(literal -1 binary64) (*.f64 y (*.f64 i (*.f64 y i))) (*.f64 z z))
(fma.f64 (*.f64 (-.f64 #s(literal 0 binary64) y) (*.f64 y i)) i (*.f64 z z))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (-.f64 (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i))))) (*.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))) (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i))))))))
(/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (-.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) (neg.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i))))))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (*.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))))) (*.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))) (+.f64 (*.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 (*.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))) (*.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))))
(/.f64 (-.f64 (*.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (*.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))))) (-.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i))))))
(pow.f64 (/.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))))) (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i))))))) #s(literal -1 binary64))
(*.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 z)))
(pow.f64 z #s(literal 2 binary64))
(pow.f64 (*.f64 z z) #s(literal 1 binary64))
(pow.f64 (exp.f64 (log.f64 z)) #s(literal 2 binary64))
(*.f64 z z)
(*.f64 (exp.f64 (log.f64 z)) (exp.f64 (log.f64 z)))
(exp.f64 (*.f64 (log.f64 (*.f64 y i)) #s(literal 2 binary64)))
(pow.f64 (*.f64 y i) #s(literal 2 binary64))
(pow.f64 (-.f64 #s(literal 0 binary64) (*.f64 y i)) #s(literal 2 binary64))
(*.f64 y (*.f64 i (*.f64 y i)))
(*.f64 i (*.f64 y (*.f64 y i)))
(*.f64 i (*.f64 (*.f64 y i) y))
(*.f64 (*.f64 y i) (*.f64 y i))
(*.f64 (*.f64 i (*.f64 y i)) y)
(*.f64 (*.f64 i i) (*.f64 y y))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 y i)) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(*.f64 (*.f64 y y) (*.f64 i i))
(*.f64 (*.f64 y (*.f64 y i)) i)
(*.f64 (*.f64 (*.f64 y i) y) i)
(*.f64 b (log.f64 c))
(*.f64 (log.f64 c) b)
(log.f64 c)
(+.f64 (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 a #s(literal 1 binary64)))
(+.f64 (*.f64 a #s(literal 1 binary64)) (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))
(+.f64 (*.f64 y (*.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) (*.f64 y i))
(+.f64 (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) y) (*.f64 y i))
(fma.f64 a #s(literal 1 binary64) (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))
(fma.f64 y (/.f64 a y) (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))
(fma.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (*.f64 a #s(literal 1 binary64)))
(fma.f64 y (*.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (*.f64 y i))
(fma.f64 (/.f64 a y) y (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))
(fma.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) y (*.f64 a #s(literal 1 binary64)))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) y (*.f64 y i))
(fma.f64 (*.f64 y a) (/.f64 #s(literal 1 binary64) y) (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))
(/.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) #s(literal 1 binary64)) (pow.f64 (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) #s(literal 3 binary64))) (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (*.f64 a #s(literal 1 binary64))) (-.f64 (pow.f64 (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) #s(literal 2 binary64)) (*.f64 (*.f64 a #s(literal 1 binary64)) (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))))
(/.f64 (-.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (*.f64 a #s(literal 1 binary64))) (pow.f64 (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) #s(literal 2 binary64))) (-.f64 (*.f64 a #s(literal 1 binary64)) (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))
(/.f64 (*.f64 y (+.f64 (/.f64 (*.f64 a (*.f64 a a)) (*.f64 y (*.f64 y y))) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 3 binary64)))) (+.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (*.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (-.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (/.f64 a y)))))
(/.f64 (*.f64 y (-.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 2 binary64)))) (-.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) y) i))
(/.f64 (*.f64 (+.f64 (/.f64 (*.f64 a (*.f64 a a)) (*.f64 y (*.f64 y y))) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 3 binary64))) y) (+.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (*.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (-.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (/.f64 a y)))))
(/.f64 (*.f64 (-.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 2 binary64))) y) (-.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) y) i))
(/.f64 (+.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (/.f64 y a) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 (/.f64 y a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 y (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (/.f64 y a) (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 (/.f64 y a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (/.f64 y a) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y))) (*.f64 (/.f64 y a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 y (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (/.f64 y a) (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y))) (*.f64 (/.f64 y a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 a y) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 y (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (*.f64 a y) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 y (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 y (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 a y) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 y (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y))) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (*.f64 a y) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 y (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y))) (*.f64 y (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 y #s(literal 1 binary64)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (/.f64 y a) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 (/.f64 y a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (*.f64 y #s(literal 1 binary64)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (/.f64 y a) (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 (/.f64 y a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 y #s(literal 1 binary64)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (/.f64 y a) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y))) (*.f64 (/.f64 y a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (*.f64 y #s(literal 1 binary64)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (/.f64 y a) (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y))) (*.f64 (/.f64 y a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) a) y) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) a) y) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (-.f64 #s(literal 0 binary64) y) (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) a) y) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y))) (*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 #s(literal 0 binary64) a) y) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (-.f64 #s(literal 0 binary64) y) (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y))) (*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) y) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (/.f64 y a) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 (/.f64 y a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) y) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (/.f64 y a) (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 (/.f64 y a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) y) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (/.f64 y a) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y))) (*.f64 (/.f64 y a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) y) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (/.f64 y a) (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y))) (*.f64 (/.f64 y a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 y a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 y (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (*.f64 y a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 y (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 y (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 y a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 y (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y))) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (*.f64 y a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 y (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y))) (*.f64 y (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 y (-.f64 #s(literal 0 binary64) a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (*.f64 y (-.f64 #s(literal 0 binary64) a)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (-.f64 #s(literal 0 binary64) y) (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 y (-.f64 #s(literal 0 binary64) a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y))) (*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (*.f64 y (-.f64 #s(literal 0 binary64) a)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (-.f64 #s(literal 0 binary64) y) (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y))) (*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (/.f64 y a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) y)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) y) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (*.f64 a y))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) y))
(/.f64 (+.f64 (*.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (/.f64 y a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (*.f64 y #s(literal 1 binary64)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (*.f64 (-.f64 #s(literal 0 binary64) a) y))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (/.f64 y a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (*.f64 #s(literal 1 binary64) y))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) y) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (*.f64 y a))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) y))
(/.f64 (+.f64 (*.f64 (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (*.f64 y (-.f64 #s(literal 0 binary64) a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (/.f64 y a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) y)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) y) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (*.f64 a y))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) y))
(/.f64 (+.f64 (*.f64 (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (/.f64 y a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (*.f64 y #s(literal 1 binary64)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (-.f64 #s(literal 0 binary64) y)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (*.f64 (-.f64 #s(literal 0 binary64) a) y))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (/.f64 y a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (*.f64 #s(literal 1 binary64) y))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) y) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (*.f64 y a))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) y))
(/.f64 (+.f64 (*.f64 (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (-.f64 #s(literal 0 binary64) y)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (*.f64 y (-.f64 #s(literal 0 binary64) a)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y) (/.f64 y a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) y)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y) y) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (*.f64 a y))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) y))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y) (/.f64 y a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (*.f64 y #s(literal 1 binary64)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y) (-.f64 #s(literal 0 binary64) y)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (*.f64 (-.f64 #s(literal 0 binary64) a) y))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y) (/.f64 y a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (*.f64 #s(literal 1 binary64) y))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y) y) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (*.f64 y a))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) y))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y) (-.f64 #s(literal 0 binary64) y)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (*.f64 y (-.f64 #s(literal 0 binary64) a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y) (/.f64 y a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) y)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y) y) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (*.f64 a y))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) y))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y) (/.f64 y a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (*.f64 y #s(literal 1 binary64)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y) (-.f64 #s(literal 0 binary64) y)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (*.f64 (-.f64 #s(literal 0 binary64) a) y))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y) (/.f64 y a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (*.f64 #s(literal 1 binary64) y))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y) y) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (*.f64 y a))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) y))
(/.f64 (+.f64 (*.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y) (-.f64 #s(literal 0 binary64) y)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (*.f64 y (-.f64 #s(literal 0 binary64) a)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 #s(literal 0 binary64) y)))
(*.f64 y (+.f64 i (*.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))))
(*.f64 (+.f64 i (*.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))))) y)
(+.f64 i (*.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))))
(+.f64 (/.f64 a y) (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (+.f64 i (/.f64 a y)))
(+.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (/.f64 a y))
(+.f64 (*.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) i)
(+.f64 (+.f64 (/.f64 a y) i) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))
(-.f64 (/.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (-.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) y) i)) (/.f64 (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 2 binary64)) (-.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) y) i)))
(fma.f64 a (/.f64 #s(literal 1 binary64) y) (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (*.f64 (log.f64 c) (/.f64 #s(literal 1 binary64) y)) (+.f64 i (/.f64 a y)))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y) (+.f64 i (/.f64 a y)))
(fma.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y) (+.f64 i (/.f64 a y)))
(fma.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (/.f64 #s(literal 1 binary64) y) (+.f64 i (/.f64 a y)))
(fma.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) y)) (+.f64 i (/.f64 a y)))
(fma.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) y)) (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))
(fma.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (/.f64 a y))
(fma.f64 #s(literal 1 binary64) (/.f64 a y) (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))
(fma.f64 #s(literal 1 binary64) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (+.f64 i (/.f64 a y)))
(fma.f64 (/.f64 #s(literal 1 binary64) y) a (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))
(fma.f64 (/.f64 #s(literal 1 binary64) y) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (+.f64 i (/.f64 a y)))
(fma.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) i)
(fma.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (/.f64 a y))
(fma.f64 (/.f64 (+.f64 b #s(literal -1/2 binary64)) y) (log.f64 c) (+.f64 i (/.f64 a y)))
(/.f64 (+.f64 (/.f64 (*.f64 a (*.f64 a a)) (*.f64 y (*.f64 y y))) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 3 binary64))) (+.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (*.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (-.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (/.f64 a y)))))
(/.f64 (+.f64 (/.f64 (*.f64 a (*.f64 a a)) (*.f64 y (*.f64 y y))) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 2 binary64)) (/.f64 (-.f64 (/.f64 a y) (*.f64 #s(literal 1 binary64) (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (/.f64 y a))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (*.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (-.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (/.f64 a y)))) (+.f64 (/.f64 (*.f64 a (*.f64 a a)) (*.f64 y (*.f64 y y))) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) y) i) (-.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 2 binary64)))))
(/.f64 (-.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 2 binary64))) (-.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) y) i))
(/.f64 (+.f64 (*.f64 a (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 a (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 y (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (/.f64 y a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (/.f64 y a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (/.f64 y a) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 (/.f64 y a) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) y))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (-.f64 #s(literal 0 binary64) y)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (-.f64 #s(literal 0 binary64) a))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (/.f64 y a)) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) y))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) (-.f64 #s(literal 0 binary64) y)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 #s(literal 0 binary64) a))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) (/.f64 y a)) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (/.f64 y a)))
(/.f64 (neg.f64 (+.f64 (/.f64 (*.f64 a (*.f64 a a)) (*.f64 y (*.f64 y y))) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (*.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (-.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (/.f64 a y))))))
(/.f64 (neg.f64 (-.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) y) i)))
(/.f64 (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (+.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (-.f64 (*.f64 i i) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) i))))
(/.f64 (-.f64 (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 2 binary64)) (/.f64 (/.f64 a y) (/.f64 y a))) (-.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (/.f64 a y)))
(/.f64 (-.f64 (pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) #s(literal 2 binary64)) (*.f64 i i)) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) i))
(/.f64 (+.f64 (*.f64 a (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 y (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 a (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 y #s(literal 1 binary64))) (*.f64 y (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))))
(/.f64 (+.f64 (*.f64 a (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 y #s(literal 1 binary64))) (*.f64 y (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))))
(/.f64 (+.f64 (*.f64 a (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))) (*.f64 y (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 y (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))))
(/.f64 (+.f64 (*.f64 a (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))) (*.f64 y (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 y (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))))
(/.f64 (+.f64 (*.f64 a (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 y (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))))) (*.f64 y (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) a) (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (-.f64 #s(literal 0 binary64) y) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 (-.f64 #s(literal 0 binary64) y) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) a) (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))) (*.f64 (-.f64 #s(literal 0 binary64) y) (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 (/.f64 y a) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (/.f64 y a) (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (/.f64 y a) #s(literal 1 binary64))) (*.f64 (/.f64 y a) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 (/.f64 y a) #s(literal 1 binary64))) (*.f64 (/.f64 y a) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))) (*.f64 (/.f64 y a) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 (/.f64 y a) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))) (*.f64 (/.f64 y a) (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 (/.f64 y a) (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 (/.f64 y a) (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))))) (*.f64 (/.f64 y a) (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) #s(literal 1 binary64))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) #s(literal 1 binary64))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))))) (*.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (neg.f64 (/.f64 y a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (neg.f64 (/.f64 y a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 (neg.f64 (/.f64 y a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (neg.f64 (/.f64 y a)) (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (neg.f64 (/.f64 y a)) #s(literal 1 binary64))) (*.f64 (neg.f64 (/.f64 y a)) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 (neg.f64 (/.f64 y a)) #s(literal 1 binary64))) (*.f64 (neg.f64 (/.f64 y a)) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (neg.f64 (/.f64 y a)) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 (neg.f64 (/.f64 y a)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))) (*.f64 (neg.f64 (/.f64 y a)) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 (neg.f64 (/.f64 y a)) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))) (*.f64 (neg.f64 (/.f64 y a)) (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 (neg.f64 (/.f64 y a)) (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 (neg.f64 (/.f64 y a)) (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (/.f64 y a)) (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 y (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 y (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 y #s(literal 1 binary64))) (*.f64 y (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 y #s(literal 1 binary64))) (*.f64 y (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 y (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 y (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))) (*.f64 y (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 y (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))) (*.f64 y (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 y (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))))
(/.f64 (+.f64 (*.f64 (*.f64 a #s(literal 1 binary64)) (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 y (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))))) (*.f64 y (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) a)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) a)) (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) a)) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) #s(literal 1 binary64))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) a)) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) #s(literal 1 binary64))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) a)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) a)) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) a)) (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) a)) (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) y)) (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (/.f64 (/.f64 y a) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (/.f64 (/.f64 y a) #s(literal 1 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (neg.f64 (/.f64 y a))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) #s(literal -1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (neg.f64 (/.f64 y a))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (*.f64 a #s(literal 1 binary64)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) y))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (neg.f64 (-.f64 #s(literal 0 binary64) y))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (neg.f64 (-.f64 #s(literal 0 binary64) a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (neg.f64 (-.f64 #s(literal 0 binary64) y))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) a)) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) y))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (-.f64 #s(literal 0 binary64) y)) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (-.f64 #s(literal 0 binary64) a))) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (/.f64 y a)) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (/.f64 (/.f64 y a) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (/.f64 (/.f64 y a) #s(literal 1 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (neg.f64 (/.f64 y a))) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) #s(literal -1 binary64))) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (neg.f64 (/.f64 y a))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) y) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (*.f64 a #s(literal 1 binary64)))) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) y))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (neg.f64 (-.f64 #s(literal 0 binary64) y))) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (neg.f64 (-.f64 #s(literal 0 binary64) a)))) (*.f64 (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))) (neg.f64 (-.f64 #s(literal 0 binary64) y))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) y) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) a)) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) y))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) y)) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (-.f64 #s(literal 0 binary64) a))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 y a)) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) #s(literal 1 binary64))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 (/.f64 y a) #s(literal 1 binary64))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) #s(literal 1 binary64))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (/.f64 (/.f64 y a) #s(literal 1 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (/.f64 y a))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) #s(literal -1 binary64))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (neg.f64 (/.f64 y a))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) y) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (*.f64 a #s(literal 1 binary64)))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) y))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (-.f64 #s(literal 0 binary64) y))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (neg.f64 (-.f64 #s(literal 0 binary64) a)))) (*.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (neg.f64 (-.f64 #s(literal 0 binary64) y))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) y) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) a)) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) y))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) y)) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (-.f64 #s(literal 0 binary64) a))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 y a)) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) #s(literal 1 binary64))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 (/.f64 y a) #s(literal 1 binary64))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) #s(literal 1 binary64))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (/.f64 (/.f64 y a) #s(literal 1 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (/.f64 y a))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) #s(literal -1 binary64))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (neg.f64 (/.f64 y a))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) y) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (*.f64 a #s(literal 1 binary64)))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) y))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (-.f64 #s(literal 0 binary64) y))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (neg.f64 (-.f64 #s(literal 0 binary64) a)))) (*.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (neg.f64 (-.f64 #s(literal 0 binary64) y))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) (/.f64 (/.f64 y a) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (/.f64 (/.f64 y a) #s(literal 1 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) (neg.f64 (/.f64 y a))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) #s(literal -1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (neg.f64 (/.f64 y a))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) y) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (*.f64 a #s(literal 1 binary64)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) y))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) (neg.f64 (-.f64 #s(literal 0 binary64) y))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (neg.f64 (-.f64 #s(literal 0 binary64) a)))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (neg.f64 (-.f64 #s(literal 0 binary64) y))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) y) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) a)) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) y))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y)) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (-.f64 #s(literal 0 binary64) a))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (/.f64 y a)) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) #s(literal 1 binary64))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (/.f64 (/.f64 y a) #s(literal 1 binary64))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) #s(literal 1 binary64))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (/.f64 (/.f64 y a) #s(literal 1 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (neg.f64 (/.f64 y a))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) #s(literal -1 binary64))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (neg.f64 (/.f64 y a))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) y) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (*.f64 a #s(literal 1 binary64)))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) y))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (neg.f64 (-.f64 #s(literal 0 binary64) y))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (neg.f64 (-.f64 #s(literal 0 binary64) a)))) (*.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))) (neg.f64 (-.f64 #s(literal 0 binary64) y))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) y) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) a)) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) y))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (-.f64 #s(literal 0 binary64) y)) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (-.f64 #s(literal 0 binary64) a))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (/.f64 y a)) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) #s(literal 1 binary64))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (/.f64 (/.f64 y a) #s(literal 1 binary64))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) #s(literal 1 binary64))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (/.f64 (/.f64 y a) #s(literal 1 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (neg.f64 (/.f64 y a))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) #s(literal -1 binary64))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (neg.f64 (/.f64 y a))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) y) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (*.f64 a #s(literal 1 binary64)))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) y))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (neg.f64 (-.f64 #s(literal 0 binary64) y))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (neg.f64 (-.f64 #s(literal 0 binary64) a)))) (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (neg.f64 (-.f64 #s(literal 0 binary64) y))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))) y) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) a)) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) y))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) y)) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (-.f64 #s(literal 0 binary64) a))) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (-.f64 #s(literal 0 binary64) y)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))) (/.f64 y a)) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 1 binary64))) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (/.f64 y a)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))) (/.f64 (/.f64 y a) #s(literal 1 binary64))) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 1 binary64))) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (/.f64 (/.f64 y a) #s(literal 1 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))) (neg.f64 (/.f64 y a))) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal -1 binary64))) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (neg.f64 (/.f64 y a))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))) y) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (*.f64 a #s(literal 1 binary64)))) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) y))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))) (neg.f64 (-.f64 #s(literal 0 binary64) y))) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (neg.f64 (-.f64 #s(literal 0 binary64) a)))) (*.f64 (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (neg.f64 (-.f64 #s(literal 0 binary64) y))))
(pow.f64 (/.f64 (+.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (*.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (-.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (/.f64 a y)))) (+.f64 (/.f64 (*.f64 a (*.f64 a a)) (*.f64 y (*.f64 y y))) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) y) i) (-.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (+.f64 (/.f64 (*.f64 a (*.f64 a a)) (*.f64 y (*.f64 y y))) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (*.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (-.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) (/.f64 a y))))))
(*.f64 (-.f64 (/.f64 (/.f64 a y) (/.f64 y a)) (pow.f64 (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (/.f64 (-.f64 a (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) y) i)))
(exp.f64 (*.f64 (log.f64 (/.f64 y a)) #s(literal -1 binary64)))
(neg.f64 (/.f64 a (-.f64 #s(literal 0 binary64) y)))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) a) y))
(/.f64 a y)
(/.f64 (-.f64 #s(literal 0 binary64) a) (-.f64 #s(literal 0 binary64) y))
(/.f64 #s(literal 1 binary64) (/.f64 y a))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 y a) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 y a)))
(/.f64 (*.f64 a #s(literal 1 binary64)) y)
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) a)) (neg.f64 (-.f64 #s(literal 0 binary64) y)))
(pow.f64 (/.f64 y a) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 y a) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 a (/.f64 #s(literal 1 binary64) y))
(*.f64 (-.f64 #s(literal 0 binary64) a) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) y)))
(*.f64 #s(literal 1 binary64) (/.f64 a y))
(*.f64 (/.f64 #s(literal 1 binary64) y) a)
(*.f64 (/.f64 #s(literal 1 binary64) y) (pow.f64 (/.f64 #s(literal 1 binary64) a) #s(literal -1 binary64)))
(+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))
(+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)
(-.f64 (/.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)) (/.f64 (*.f64 i i) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (*.f64 (log.f64 c) (/.f64 #s(literal 1 binary64) y)) i)
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y) i)
(fma.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y) i)
(fma.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (/.f64 #s(literal 1 binary64) y) i)
(fma.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) y)) i)
(fma.f64 #s(literal 1 binary64) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)
(fma.f64 (/.f64 #s(literal 1 binary64) y) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) i)
(fma.f64 (/.f64 (+.f64 b #s(literal -1/2 binary64)) y) (log.f64 c) i)
(/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))))
(/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (+.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) (*.f64 #s(literal 1 binary64) i)) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))))
(/.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i))
(/.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) (neg.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) (neg.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(/.f64 (-.f64 (*.f64 i i) (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64))) (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))
(pow.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))))) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i) (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 3 binary64)) (*.f64 i (*.f64 i i))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i (-.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))))))
(*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) #s(literal 2 binary64)) (*.f64 i i)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)) i)))
(*.f64 y (*.f64 i i))
(*.f64 i (*.f64 y i))
(*.f64 (*.f64 y i) i)
(*.f64 (*.f64 i i) y)
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))) #s(literal -1 binary64)))
(neg.f64 (/.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (-.f64 #s(literal 0 binary64) y)))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) y))
(/.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) y)
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (-.f64 #s(literal 0 binary64) y))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c))))
(/.f64 (*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 1 binary64)) y)
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))) (neg.f64 (-.f64 #s(literal 0 binary64) y)))
(pow.f64 (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (/.f64 y (+.f64 b #s(literal -1/2 binary64))) (log.f64 c)) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (*.f64 (log.f64 c) (/.f64 #s(literal 1 binary64) y)))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y))
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(*.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) (/.f64 #s(literal 1 binary64) y))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) y)))
(*.f64 #s(literal 1 binary64) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))
(*.f64 (/.f64 #s(literal 1 binary64) y) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)))
(*.f64 (/.f64 #s(literal 1 binary64) y) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))) #s(literal -1 binary64)))
(*.f64 (/.f64 (+.f64 b #s(literal -1/2 binary64)) y) (log.f64 c))
(+.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(+.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 b (log.f64 c)))
(fma.f64 b (log.f64 c) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(fma.f64 (log.f64 c) b (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(fma.f64 (log.f64 c) #s(literal -1/2 binary64) (*.f64 b (log.f64 c)))
(fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 b (log.f64 c)))
(/.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (-.f64 (*.f64 b (log.f64 c)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))
(/.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))))
(/.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 b #s(literal 1/2 binary64)))
(/.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 (+.f64 (*.f64 b b) #s(literal 1/4 binary64)) (*.f64 b #s(literal -1/2 binary64))))
(/.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 b b) (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))))
(/.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 b #s(literal 1/2 binary64)))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))

simplify299.0ms (2.3%)

Algorithm
1×egg-herbie
Rules
4272×*-lowering-*.f32
4272×*-lowering-*.f64
2090×+-lowering-+.f64
2090×+-lowering-+.f32
1510×sum3-define
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
03316058
111415463
239845316
081405316
Stop Event
1×iter limit
1×node limit
Counts
588 → 588
Calls
Call 1
Inputs
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
z
(* z (+ 1 (+ (/ a z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) z)) 1)))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
a
(* a (+ 1 (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))
(* a (+ 1 (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))
(* a (+ 1 (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))
a
(* -1 (* a (- (* -1 (/ (+ z (+ (* i y) (* (log c) (- b 1/2)))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ z (+ (* i y) (* (log c) (- b 1/2)))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ z (+ (* i y) (* (log c) (- b 1/2)))) a)) 1)))
(+ a (+ z (+ (* -1/2 (log c)) (* i y))))
(+ a (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))
(+ a (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))
(+ a (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ z b) (/ (* i y) b))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ z b) (/ (* i y) b))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ z b) (/ (* i y) b))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (+ (* -1/2 (log c)) (* i y)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (+ (* -1/2 (log c)) (* i y)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (+ (* -1/2 (log c)) (* i y)))) b)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))
(+ a (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))
(+ a (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))
(+ a (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))
(+ a (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(* i y)
(* y (+ i (+ (/ a y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))
(* y (+ i (+ (/ a y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))
(* y (+ i (+ (/ a y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) y)))))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))
(* i (+ y (+ (/ a i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))
(* i (+ y (+ (/ a i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) i)))))
(+ a (* (log c) (- b 1/2)))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
z
(* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))
(* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))
(* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))
z
(* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))
(+ z (* (log c) (- b 1/2)))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
a
(* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
a
(* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))
(+ a (+ z (* -1/2 (log c))))
(+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))
(+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))
(+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
a
(+ a z)
(+ a z)
(+ a z)
z
(* z (+ 1 (/ a z)))
(* z (+ 1 (/ a z)))
(* z (+ 1 (/ a z)))
z
(* -1 (* z (- (* -1 (/ a z)) 1)))
(* -1 (* z (- (* -1 (/ a z)) 1)))
(* -1 (* z (- (* -1 (/ a z)) 1)))
z
(+ a z)
(+ a z)
(+ a z)
a
(* a (+ 1 (/ z a)))
(* a (+ 1 (/ z a)))
(* a (+ 1 (/ z a)))
a
(* -1 (* a (- (* -1 (/ z a)) 1)))
(* -1 (* a (- (* -1 (/ z a)) 1)))
(* -1 (* a (- (* -1 (/ z a)) 1)))
(* -1/2 (log c))
(+ (* -1/2 (log c)) (* b (log c)))
(+ (* -1/2 (log c)) (* b (log c)))
(+ (* -1/2 (log c)) (* b (log c)))
(* b (log c))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* i y)
(+ z (* i y))
(+ z (* i y))
(+ z (* i y))
z
(* z (+ 1 (/ (* i y) z)))
(* z (+ 1 (/ (* i y) z)))
(* z (+ 1 (/ (* i y) z)))
z
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
z
(+ z (* i y))
(+ z (* i y))
(+ z (* i y))
(* i y)
(* y (+ i (/ z y)))
(* y (+ i (/ z y)))
(* y (+ i (/ z y)))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
z
(+ z (* i y))
(+ z (* i y))
(+ z (* i y))
(* i y)
(* i (+ y (/ z i)))
(* i (+ y (/ z i)))
(* i (+ y (/ z i)))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(* -1 (* (pow i 2) (pow y 2)))
(- (pow z 2) (* (pow i 2) (pow y 2)))
(- (pow z 2) (* (pow i 2) (pow y 2)))
(- (pow z 2) (* (pow i 2) (pow y 2)))
(pow z 2)
(* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(pow z 2)
(* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(pow z 2)
(+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))
(+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))
(+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))
(* -1 (* (pow i 2) (pow y 2)))
(* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))
(* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))
(* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))
(* -1 (* (pow i 2) (pow y 2)))
(* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))
(* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))
(* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))
(pow z 2)
(+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))
(+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))
(+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))
(* -1 (* (pow i 2) (pow y 2)))
(* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))
(* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))
(* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))
(* -1 (* (pow i 2) (pow y 2)))
(* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))
(* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))
(* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* b (log c))
(* b (log c))
(* b (log c))
(* b (log c))
(* -1 (* b (log (/ 1 c))))
(* -1 (* b (log (/ 1 c))))
(* -1 (* b (log (/ 1 c))))
(* -1 (* b (log (/ 1 c))))
(* b (+ (log -1) (* -1 (log (/ -1 c)))))
(* b (+ (log -1) (* -1 (log (/ -1 c)))))
(* b (+ (log -1) (* -1 (log (/ -1 c)))))
(* b (+ (log -1) (* -1 (log (/ -1 c)))))
(* b (log c))
(* b (log c))
(* b (log c))
(* b (log c))
(* b (log c))
(* b (log c))
(* b (log c))
(* b (log c))
(* b (log c))
(* b (log c))
(* b (log c))
(* b (log c))
(log c)
(log c)
(log c)
(log c)
(* -1 (log (/ 1 c)))
(* -1 (log (/ 1 c)))
(* -1 (log (/ 1 c)))
(* -1 (log (/ 1 c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ a (* (log c) (- b 1/2)))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(* i y)
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(* i y)
(* -1 (* y (+ (* -1 i) (+ (* -1 (/ a y)) (* -1 (/ (* (log c) (- b 1/2)) y))))))
(* -1 (* y (+ (* -1 i) (+ (* -1 (/ a y)) (* -1 (/ (* (log c) (- b 1/2)) y))))))
(* -1 (* y (+ (* -1 i) (+ (* -1 (/ a y)) (* -1 (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (/ (* (log c) (- b 1/2)) y)))
(+ a (* y (+ i (/ (* (log c) (- b 1/2)) y))))
(+ a (* y (+ i (/ (* (log c) (- b 1/2)) y))))
(+ a (* y (+ i (/ (* (log c) (- b 1/2)) y))))
a
(* a (+ 1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)))
(* a (+ 1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)))
(* a (+ 1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)))
a
(* -1 (* a (- (* -1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)) 1)))
(* -1 (* a (- (* -1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)) 1)))
(* -1 (* a (- (* -1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)) 1)))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y))))
(* y (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y))))
(* y (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y))))
(* y (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y))))
(* y (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))))
(* y (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))))
(* y (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))))
(* y (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))))
(* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y))))
(+ (* b (log c)) (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))))
(+ (* b (log c)) (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))))
(+ (* b (log c)) (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))))
(* b (log c))
(* b (+ (log c) (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))
(* b (+ (log c) (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))
(* b (+ (log c) (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))))
(* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+ (* i y) (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(+ (* i y) (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(+ (* i y) (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(* i y)
(* i (+ y (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))
(* i (+ y (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))
(* i (+ y (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))))
(+ i (/ (* (log c) (- b 1/2)) y))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(/ a y)
(* a (+ (/ 1 y) (+ (/ i a) (/ (* (log c) (- b 1/2)) (* a y)))))
(* a (+ (/ 1 y) (+ (/ i a) (/ (* (log c) (- b 1/2)) (* a y)))))
(* a (+ (/ 1 y) (+ (/ i a) (/ (* (log c) (- b 1/2)) (* a y)))))
(/ a y)
(* -1 (* a (- (* -1 (/ (+ i (/ (* (log c) (- b 1/2)) y)) a)) (/ 1 y))))
(* -1 (* a (- (* -1 (/ (+ i (/ (* (log c) (- b 1/2)) y)) a)) (/ 1 y))))
(* -1 (* a (- (* -1 (/ (+ i (/ (* (log c) (- b 1/2)) y)) a)) (/ 1 y))))
(/ (+ a (* (log c) (- b 1/2))) y)
(/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) y)
(/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) y)
(/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) y)
i
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
i
(+ i (* -1 (/ (+ (* -1 a) (* -1 (* (log c) (- b 1/2)))) y)))
(+ i (* -1 (/ (+ (* -1 a) (* -1 (* (log c) (- b 1/2)))) y)))
(+ i (* -1 (/ (+ (* -1 a) (* -1 (* (log c) (- b 1/2)))) y)))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y)))
(+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y)))
(+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y)))
(+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y)))
(+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)))
(+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)))
(+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)))
(+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)))
(+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))
(+ i (+ (* -1/2 (/ (log c) y)) (+ (/ a y) (/ (* b (log c)) y))))
(+ i (+ (* -1/2 (/ (log c) y)) (+ (/ a y) (/ (* b (log c)) y))))
(+ i (+ (* -1/2 (/ (log c) y)) (+ (/ a y) (/ (* b (log c)) y))))
(/ (* b (log c)) y)
(* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ a (* b y)) (+ (/ i b) (/ (log c) y)))))
(* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ a (* b y)) (+ (/ i b) (/ (log c) y)))))
(* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ a (* b y)) (+ (/ i b) (/ (log c) y)))))
(/ (* b (log c)) y)
(* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (+ (* -1/2 (/ (log c) y)) (/ a y))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (+ (* -1/2 (/ (log c) y)) (/ a y))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (+ (* -1/2 (/ (log c) y)) (/ a y))) b)))))
(+ (/ a y) (/ (* (log c) (- b 1/2)) y))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
i
(* i (+ 1 (+ (/ a (* i y)) (/ (* (log c) (- b 1/2)) (* i y)))))
(* i (+ 1 (+ (/ a (* i y)) (/ (* (log c) (- b 1/2)) (* i y)))))
(* i (+ 1 (+ (/ a (* i y)) (/ (* (log c) (- b 1/2)) (* i y)))))
i
(* -1 (* i (- (* -1 (/ (+ (/ a y) (/ (* (log c) (- b 1/2)) y)) i)) 1)))
(* -1 (* i (- (* -1 (/ (+ (/ a y) (/ (* (log c) (- b 1/2)) y)) i)) 1)))
(* -1 (* i (- (* -1 (/ (+ (/ a y) (/ (* (log c) (- b 1/2)) y)) i)) 1)))
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(/ a y)
(+ i (/ (* (log c) (- b 1/2)) y))
(+ i (/ (* (log c) (- b 1/2)) y))
(+ i (/ (* (log c) (- b 1/2)) y))
(+ i (/ (* (log c) (- b 1/2)) y))
(+ i (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)))
(+ i (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)))
(+ i (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)))
(+ i (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)))
(+ i (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))
(+ i (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))
(+ i (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))
(+ i (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))
(+ i (* -1/2 (/ (log c) y)))
(+ i (+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y)))
(+ i (+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y)))
(+ i (+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y)))
(/ (* b (log c)) y)
(* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ i b) (/ (log c) y))))
(* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ i b) (/ (log c) y))))
(* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ i b) (/ (log c) y))))
(/ (* b (log c)) y)
(* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (* -1/2 (/ (log c) y))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (* -1/2 (/ (log c) y))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (* -1/2 (/ (log c) y))) b)))))
(/ (* (log c) (- b 1/2)) y)
(/ (+ (* i y) (* (log c) (- b 1/2))) y)
(/ (+ (* i y) (* (log c) (- b 1/2))) y)
(/ (+ (* i y) (* (log c) (- b 1/2))) y)
i
(+ i (/ (* (log c) (- b 1/2)) y))
(+ i (/ (* (log c) (- b 1/2)) y))
(+ i (/ (* (log c) (- b 1/2)) y))
i
(+ i (/ (* (log c) (- b 1/2)) y))
(+ i (/ (* (log c) (- b 1/2)) y))
(+ i (/ (* (log c) (- b 1/2)) y))
(/ (* (log c) (- b 1/2)) y)
(+ i (/ (* (log c) (- b 1/2)) y))
(+ i (/ (* (log c) (- b 1/2)) y))
(+ i (/ (* (log c) (- b 1/2)) y))
i
(* i (+ 1 (/ (* (log c) (- b 1/2)) (* i y))))
(* i (+ 1 (/ (* (log c) (- b 1/2)) (* i y))))
(* i (+ 1 (/ (* (log c) (- b 1/2)) (* i y))))
i
(* -1 (* i (- (* -1 (/ (* (log c) (- b 1/2)) (* i y))) 1)))
(* -1 (* i (- (* -1 (/ (* (log c) (- b 1/2)) (* i y))) 1)))
(* -1 (* i (- (* -1 (/ (* (log c) (- b 1/2)) (* i y))) 1)))
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(* (pow i 2) y)
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y))
(* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y))
(* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y))
(* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y))
(/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)
(/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)
(/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)
(/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)
(* -1/2 (/ (log c) y))
(+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y))
(+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y))
(+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y))
(/ (* b (log c)) y)
(* b (+ (* -1/2 (/ (log c) (* b y))) (/ (log c) y)))
(* b (+ (* -1/2 (/ (log c) (* b y))) (/ (log c) y)))
(* b (+ (* -1/2 (/ (log c) (* b y))) (/ (log c) y)))
(/ (* b (log c)) y)
(* -1 (* b (+ (* -1 (/ (log c) y)) (* 1/2 (/ (log c) (* b y))))))
(* -1 (* b (+ (* -1 (/ (log c) y)) (* 1/2 (/ (log c) (* b y))))))
(* -1 (* b (+ (* -1 (/ (log c) y)) (* 1/2 (/ (log c) (* b y))))))
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(/ (* (log c) (- b 1/2)) y)
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* -1/2 (log c))
(+ (* -1/2 (log c)) (* b (log c)))
(+ (* -1/2 (log c)) (* b (log c)))
(+ (* -1/2 (log c)) (* b (log c)))
(* b (log c))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
Outputs
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y)))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
z
(* z (+ 1 (+ (/ a z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))
(*.f64 z (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (/.f64 (*.f64 i y) z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))))
(* z (+ 1 (+ (/ a z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))
(*.f64 z (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (/.f64 (*.f64 i y) z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))))
(* z (+ 1 (+ (/ a z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))
(*.f64 z (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (/.f64 (*.f64 i y) z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) z)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y))) z)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) z)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y))) z)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) z)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y))) z)) (-.f64 #s(literal 0 binary64) z))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
a
(* a (+ 1 (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))
(*.f64 a (+.f64 (+.f64 (/.f64 (*.f64 i y) a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) a))) (+.f64 #s(literal 1 binary64) (/.f64 z a))))
(* a (+ 1 (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))
(*.f64 a (+.f64 (+.f64 (/.f64 (*.f64 i y) a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) a))) (+.f64 #s(literal 1 binary64) (/.f64 z a))))
(* a (+ 1 (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))
(*.f64 a (+.f64 (+.f64 (/.f64 (*.f64 i y) a) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) a))) (+.f64 #s(literal 1 binary64) (/.f64 z a))))
a
(* -1 (* a (- (* -1 (/ (+ z (+ (* i y) (* (log c) (- b 1/2)))) a)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 a (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)) a))))
(* -1 (* a (- (* -1 (/ (+ z (+ (* i y) (* (log c) (- b 1/2)))) a)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 a (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)) a))))
(* -1 (* a (- (* -1 (/ (+ z (+ (* i y) (* (log c) (- b 1/2)))) a)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 a (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)) a))))
(+ a (+ z (+ (* -1/2 (log c)) (* i y))))
(+.f64 (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y)))
(+ a (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ z b) (/ (* i y) b))))))
(*.f64 b (+.f64 (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (/.f64 a b))) (+.f64 (/.f64 z b) (/.f64 (*.f64 i y) b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ z b) (/ (* i y) b))))))
(*.f64 b (+.f64 (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (/.f64 a b))) (+.f64 (/.f64 z b) (/.f64 (*.f64 i y) b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ z b) (/ (* i y) b))))))
(*.f64 b (+.f64 (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (/.f64 a b))) (+.f64 (/.f64 z b) (/.f64 (*.f64 i y) b))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (+ (* -1/2 (log c)) (* i y)))) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (+.f64 (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y))) b)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (+ (* -1/2 (log c)) (* i y)))) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (+.f64 (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y))) b)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (+ (* -1/2 (log c)) (* i y)))) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (+.f64 (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y))) b)))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+.f64 a (+.f64 z (+.f64 (*.f64 i y) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))))
(+ a (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+.f64 a (+.f64 z (+.f64 (*.f64 i y) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))))
(+ a (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+.f64 a (+.f64 z (+.f64 (*.f64 i y) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))))
(+ a (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+.f64 a (+.f64 z (+.f64 (*.f64 i y) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(* i y)
(*.f64 i y)
(* y (+ i (+ (/ a y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))
(*.f64 y (+.f64 (+.f64 (/.f64 a y) (/.f64 z y)) (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* y (+ i (+ (/ a y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))
(*.f64 y (+.f64 (+.f64 (/.f64 a y) (/.f64 z y)) (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* y (+ i (+ (/ a y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))
(*.f64 y (+.f64 (+.f64 (/.f64 a y) (/.f64 z y)) (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) y)))))
(*.f64 y (+.f64 i (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z)) y)))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) y)))))
(*.f64 y (+.f64 i (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z)) y)))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) y)))))
(*.f64 y (+.f64 i (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z)) y)))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 i y) z)))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))
(*.f64 i (+.f64 (+.f64 (+.f64 y (/.f64 a i)) (/.f64 z i)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i))))
(* i (+ y (+ (/ a i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))
(*.f64 i (+.f64 (+.f64 (+.f64 y (/.f64 a i)) (/.f64 z i)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i))))
(* i (+ y (+ (/ a i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))
(*.f64 i (+.f64 (+.f64 (+.f64 y (/.f64 a i)) (/.f64 z i)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i))))
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) i)))))
(*.f64 i (+.f64 y (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z)) i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) i)))))
(*.f64 i (+.f64 y (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z)) i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) i)))))
(*.f64 i (+.f64 y (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z)) i)))
(+ a (* (log c) (- b 1/2)))
(+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
z
(* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 a z) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z)))))
(* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 a z) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z)))))
(* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 a z) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z)))))
z
(* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))
(*.f64 z (-.f64 #s(literal 0 binary64) (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) z))))
(* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))
(*.f64 z (-.f64 #s(literal 0 binary64) (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) z))))
(* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))
(*.f64 z (-.f64 #s(literal 0 binary64) (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) z))))
(+ z (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) z)
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
a
(* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) a)) (+.f64 #s(literal 1 binary64) (/.f64 z a))))
(* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) a)) (+.f64 #s(literal 1 binary64) (/.f64 z a))))
(* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) a)) (+.f64 #s(literal 1 binary64) (/.f64 z a))))
a
(* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) z) a)) (-.f64 #s(literal 0 binary64) a))
(* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) z) a)) (-.f64 #s(literal 0 binary64) a))
(* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) z) a)) (-.f64 #s(literal 0 binary64) a))
(+ a (+ z (* -1/2 (log c))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64))))
(+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (/.f64 z b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (/.f64 z b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (/.f64 z b)))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (+.f64 a (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (+.f64 a (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (+.f64 a (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b)))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
a
(+ a z)
(+.f64 a z)
(+ a z)
(+.f64 a z)
(+ a z)
(+.f64 a z)
z
(* z (+ 1 (/ a z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 a z)))
(* z (+ 1 (/ a z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 a z)))
(* z (+ 1 (/ a z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 a z)))
z
(* -1 (* z (- (* -1 (/ a z)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 a z)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ a z)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 a z)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ a z)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 a z)) (-.f64 #s(literal 0 binary64) z))
z
(+ a z)
(+.f64 a z)
(+ a z)
(+.f64 a z)
(+ a z)
(+.f64 a z)
a
(* a (+ 1 (/ z a)))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 z a)))
(* a (+ 1 (/ z a)))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 z a)))
(* a (+ 1 (/ z a)))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 z a)))
a
(* -1 (* a (- (* -1 (/ z a)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 a (-.f64 #s(literal -1 binary64) (/.f64 z a))))
(* -1 (* a (- (* -1 (/ z a)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 a (-.f64 #s(literal -1 binary64) (/.f64 z a))))
(* -1 (* a (- (* -1 (/ z a)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 a (-.f64 #s(literal -1 binary64) (/.f64 z a))))
(* -1/2 (log c))
(*.f64 (log.f64 c) #s(literal -1/2 binary64))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* i y)
(*.f64 i y)
(+ z (* i y))
(+.f64 (*.f64 i y) z)
(+ z (* i y))
(+.f64 (*.f64 i y) z)
(+ z (* i y))
(+.f64 (*.f64 i y) z)
z
(* z (+ 1 (/ (* i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(* z (+ 1 (/ (* i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(* z (+ 1 (/ (* i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
z
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (*.f64 i y) z)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (*.f64 i y) z)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (*.f64 i y) z)) (-.f64 #s(literal 0 binary64) z))
z
(+ z (* i y))
(+.f64 (*.f64 i y) z)
(+ z (* i y))
(+.f64 (*.f64 i y) z)
(+ z (* i y))
(+.f64 (*.f64 i y) z)
(* i y)
(*.f64 i y)
(* y (+ i (/ z y)))
(*.f64 y (+.f64 i (/.f64 z y)))
(* y (+ i (/ z y)))
(*.f64 y (+.f64 i (/.f64 z y)))
(* y (+ i (/ z y)))
(*.f64 y (+.f64 i (/.f64 z y)))
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
(*.f64 y (+.f64 i (/.f64 z y)))
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
(*.f64 y (+.f64 i (/.f64 z y)))
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
(*.f64 y (+.f64 i (/.f64 z y)))
z
(+ z (* i y))
(+.f64 (*.f64 i y) z)
(+ z (* i y))
(+.f64 (*.f64 i y) z)
(+ z (* i y))
(+.f64 (*.f64 i y) z)
(* i y)
(*.f64 i y)
(* i (+ y (/ z i)))
(*.f64 i (+.f64 y (/.f64 z i)))
(* i (+ y (/ z i)))
(*.f64 i (+.f64 y (/.f64 z i)))
(* i (+ y (/ z i)))
(*.f64 i (+.f64 y (/.f64 z i)))
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(*.f64 i (+.f64 y (/.f64 z i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(*.f64 i (+.f64 y (/.f64 z i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(*.f64 i (+.f64 y (/.f64 z i)))
(* -1 (* (pow i 2) (pow y 2)))
(-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y))))
(- (pow z 2) (* (pow i 2) (pow y 2)))
(-.f64 (*.f64 z z) (*.f64 i (*.f64 i (*.f64 y y))))
(- (pow z 2) (* (pow i 2) (pow y 2)))
(-.f64 (*.f64 z z) (*.f64 i (*.f64 i (*.f64 y y))))
(- (pow z 2) (* (pow i 2) (pow y 2)))
(-.f64 (*.f64 z z) (*.f64 i (*.f64 i (*.f64 y y))))
(pow z 2)
(*.f64 z z)
(* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 i (*.f64 i (*.f64 y y))) (*.f64 z z))))
(* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 i (*.f64 i (*.f64 y y))) (*.f64 z z))))
(* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 i (*.f64 i (*.f64 y y))) (*.f64 z z))))
(pow z 2)
(*.f64 z z)
(* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 i (*.f64 i (*.f64 y y))) (*.f64 z z))))
(* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 i (*.f64 i (*.f64 y y))) (*.f64 z z))))
(* (pow z 2) (+ 1 (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 i (*.f64 i (*.f64 y y))) (*.f64 z z))))
(pow z 2)
(*.f64 z z)
(+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))
(-.f64 (*.f64 z z) (*.f64 i (*.f64 i (*.f64 y y))))
(+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))
(-.f64 (*.f64 z z) (*.f64 i (*.f64 i (*.f64 y y))))
(+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))
(-.f64 (*.f64 z z) (*.f64 i (*.f64 i (*.f64 y y))))
(* -1 (* (pow i 2) (pow y 2)))
(-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y))))
(* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))
(*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i))))
(* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))
(*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i))))
(* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))
(*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i))))
(* -1 (* (pow i 2) (pow y 2)))
(-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y))))
(* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))
(*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i))))
(* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))
(*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i))))
(* (pow y 2) (- (/ (pow z 2) (pow y 2)) (pow i 2)))
(*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i))))
(pow z 2)
(*.f64 z z)
(+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))
(-.f64 (*.f64 z z) (*.f64 i (*.f64 i (*.f64 y y))))
(+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))
(-.f64 (*.f64 z z) (*.f64 i (*.f64 i (*.f64 y y))))
(+ (* -1 (* (pow i 2) (pow y 2))) (pow z 2))
(-.f64 (*.f64 z z) (*.f64 i (*.f64 i (*.f64 y y))))
(* -1 (* (pow i 2) (pow y 2)))
(-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y))))
(* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y)))
(* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y)))
(* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y)))
(* -1 (* (pow i 2) (pow y 2)))
(-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y))))
(* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y)))
(* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y)))
(* (pow i 2) (- (/ (pow z 2) (pow i 2)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y)))
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* (pow i 2) (pow y 2))
(*.f64 i (*.f64 i (*.f64 y y)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (log (/ 1 c))))
(*.f64 (log.f64 c) b)
(* -1 (* b (log (/ 1 c))))
(*.f64 (log.f64 c) b)
(* -1 (* b (log (/ 1 c))))
(*.f64 (log.f64 c) b)
(* -1 (* b (log (/ 1 c))))
(*.f64 (log.f64 c) b)
(* b (+ (log -1) (* -1 (log (/ -1 c)))))
(*.f64 b (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* b (+ (log -1) (* -1 (log (/ -1 c)))))
(*.f64 b (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* b (+ (log -1) (* -1 (log (/ -1 c)))))
(*.f64 b (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* b (+ (log -1) (* -1 (log (/ -1 c)))))
(*.f64 b (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (log c))
(*.f64 (log.f64 c) b)
(log c)
(log.f64 c)
(log c)
(log.f64 c)
(log c)
(log.f64 c)
(log c)
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ a (* (log c) (- b 1/2)))
(+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y)))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y)))
(+ a (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y)))
(* i y)
(*.f64 i y)
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (+ (* -1 (/ a y)) (* -1 (/ (* (log c) (- b 1/2)) y))))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* -1 (* y (+ (* -1 i) (+ (* -1 (/ a y)) (* -1 (/ (* (log c) (- b 1/2)) y))))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* -1 (* y (+ (* -1 i) (+ (* -1 (/ a y)) (* -1 (/ (* (log c) (- b 1/2)) y))))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* y (+ i (/ (* (log c) (- b 1/2)) y)))
(*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ a (* y (+ i (/ (* (log c) (- b 1/2)) y))))
(+.f64 a (*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(+ a (* y (+ i (/ (* (log c) (- b 1/2)) y))))
(+.f64 a (*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(+ a (* y (+ i (/ (* (log c) (- b 1/2)) y))))
(+.f64 a (*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
a
(* a (+ 1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)))
(*.f64 a (+.f64 #s(literal 1 binary64) (*.f64 y (/.f64 (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) a))))
(* a (+ 1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)))
(*.f64 a (+.f64 #s(literal 1 binary64) (*.f64 y (/.f64 (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) a))))
(* a (+ 1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)))
(*.f64 a (+.f64 #s(literal 1 binary64) (*.f64 y (/.f64 (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) a))))
a
(* -1 (* a (- (* -1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (*.f64 y (/.f64 (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) a))) (-.f64 #s(literal 0 binary64) a))
(* -1 (* a (- (* -1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (*.f64 y (/.f64 (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) a))) (-.f64 #s(literal 0 binary64) a))
(* -1 (* a (- (* -1 (/ (* y (+ i (/ (* (log c) (- b 1/2)) y))) a)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (*.f64 y (/.f64 (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) a))) (-.f64 #s(literal 0 binary64) a))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* y (+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* y (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* y (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* y (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* y (+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* y (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))))
(*.f64 y (+.f64 (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)) (+.f64 i (/.f64 a y))))
(* y (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))))
(*.f64 y (+.f64 (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)) (+.f64 i (/.f64 a y))))
(* y (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))))
(*.f64 y (+.f64 (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)) (+.f64 i (/.f64 a y))))
(* y (+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))))
(*.f64 y (+.f64 (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)) (+.f64 i (/.f64 a y))))
(* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y))))
(*.f64 y (+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y))))
(+ (* b (log c)) (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))))
(+.f64 (*.f64 (log.f64 c) b) (*.f64 y (+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y)))))
(+ (* b (log c)) (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))))
(+.f64 (*.f64 (log.f64 c) b) (*.f64 y (+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y)))))
(+ (* b (log c)) (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))))
(+.f64 (*.f64 (log.f64 c) b) (*.f64 y (+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y)))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))
(*.f64 b (+.f64 (log.f64 c) (*.f64 (+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y))) (/.f64 y b))))
(* b (+ (log c) (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))
(*.f64 b (+.f64 (log.f64 c) (*.f64 (+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y))) (/.f64 y b))))
(* b (+ (log c) (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))
(*.f64 b (+.f64 (log.f64 c) (*.f64 (+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y))) (/.f64 y b))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))))
(*.f64 b (+.f64 (log.f64 c) (*.f64 (+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y))) (/.f64 y b))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))))
(*.f64 b (+.f64 (log.f64 c) (*.f64 (+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y))) (/.f64 y b))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* y (+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))) b)))))
(*.f64 b (+.f64 (log.f64 c) (*.f64 (+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y))) (/.f64 y b))))
(* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(*.f64 y (/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y))
(+ (* i y) (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(+ (* i y) (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(+ (* i y) (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 y (+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))))
(* i y)
(*.f64 i y)
(* i (+ y (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))
(*.f64 i (+.f64 y (/.f64 (*.f64 y (/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y)) i)))
(* i (+ y (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))
(*.f64 i (+.f64 y (/.f64 (*.f64 y (/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y)) i)))
(* i (+ y (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))
(*.f64 i (+.f64 y (/.f64 (*.f64 y (/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y)) i)))
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))))
(*.f64 i (+.f64 y (/.f64 (*.f64 y (/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y)) i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))))
(*.f64 i (+.f64 y (/.f64 (*.f64 y (/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y)) i)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (* y (+ (/ a y) (/ (* (log c) (- b 1/2)) y))) i)))))
(*.f64 i (+.f64 y (/.f64 (*.f64 y (/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y)) i)))
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(/ a y)
(/.f64 a y)
(* a (+ (/ 1 y) (+ (/ i a) (/ (* (log c) (- b 1/2)) (* a y)))))
(*.f64 a (+.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 (/.f64 i a) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 a y)))))
(* a (+ (/ 1 y) (+ (/ i a) (/ (* (log c) (- b 1/2)) (* a y)))))
(*.f64 a (+.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 (/.f64 i a) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 a y)))))
(* a (+ (/ 1 y) (+ (/ i a) (/ (* (log c) (- b 1/2)) (* a y)))))
(*.f64 a (+.f64 (/.f64 #s(literal 1 binary64) y) (+.f64 (/.f64 i a) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 a y)))))
(/ a y)
(/.f64 a y)
(* -1 (* a (- (* -1 (/ (+ i (/ (* (log c) (- b 1/2)) y)) a)) (/ 1 y))))
(*.f64 a (+.f64 (/.f64 (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) a) (/.f64 #s(literal 1 binary64) y)))
(* -1 (* a (- (* -1 (/ (+ i (/ (* (log c) (- b 1/2)) y)) a)) (/ 1 y))))
(*.f64 a (+.f64 (/.f64 (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) a) (/.f64 #s(literal 1 binary64) y)))
(* -1 (* a (- (* -1 (/ (+ i (/ (* (log c) (- b 1/2)) y)) a)) (/ 1 y))))
(*.f64 a (+.f64 (/.f64 (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) a) (/.f64 #s(literal 1 binary64) y)))
(/ (+ a (* (log c) (- b 1/2))) y)
(/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y)
(/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) y)
(/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y))) y)
(/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) y)
(/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y))) y)
(/ (+ a (+ (* i y) (* (log c) (- b 1/2)))) y)
(/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (*.f64 i y))) y)
i
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
i
(+ i (* -1 (/ (+ (* -1 a) (* -1 (* (log c) (- b 1/2)))) y)))
(+.f64 i (/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y))
(+ i (* -1 (/ (+ (* -1 a) (* -1 (* (log c) (- b 1/2)))) y)))
(+.f64 i (/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y))
(+ i (* -1 (/ (+ (* -1 a) (* -1 (* (log c) (- b 1/2)))) y)))
(+.f64 i (/.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)) (/ a y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)))
(+.f64 (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)) (+.f64 i (/.f64 a y)))
(+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)))
(+.f64 (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)) (+.f64 i (/.f64 a y)))
(+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)))
(+.f64 (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)) (+.f64 i (/.f64 a y)))
(+ i (+ (/ a y) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)))
(+.f64 (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)) (+.f64 i (/.f64 a y)))
(+ i (+ (* -1/2 (/ (log c) y)) (/ a y)))
(+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y)))
(+ i (+ (* -1/2 (/ (log c) y)) (+ (/ a y) (/ (* b (log c)) y))))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (/.f64 (log.f64 c) y) (+.f64 b #s(literal -1/2 binary64)))))
(+ i (+ (* -1/2 (/ (log c) y)) (+ (/ a y) (/ (* b (log c)) y))))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (/.f64 (log.f64 c) y) (+.f64 b #s(literal -1/2 binary64)))))
(+ i (+ (* -1/2 (/ (log c) y)) (+ (/ a y) (/ (* b (log c)) y))))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (/.f64 (log.f64 c) y) (+.f64 b #s(literal -1/2 binary64)))))
(/ (* b (log c)) y)
(/.f64 (*.f64 (log.f64 c) b) y)
(* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ a (* b y)) (+ (/ i b) (/ (log c) y)))))
(*.f64 b (+.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 y b)) (/.f64 a (*.f64 y b))) (/.f64 i b)) (/.f64 (log.f64 c) y)))
(* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ a (* b y)) (+ (/ i b) (/ (log c) y)))))
(*.f64 b (+.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 y b)) (/.f64 a (*.f64 y b))) (/.f64 i b)) (/.f64 (log.f64 c) y)))
(* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ a (* b y)) (+ (/ i b) (/ (log c) y)))))
(*.f64 b (+.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 y b)) (/.f64 a (*.f64 y b))) (/.f64 i b)) (/.f64 (log.f64 c) y)))
(/ (* b (log c)) y)
(/.f64 (*.f64 (log.f64 c) b) y)
(* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (+ (* -1/2 (/ (log c) y)) (/ a y))) b)))))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (/.f64 (+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y))) b)))
(* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (+ (* -1/2 (/ (log c) y)) (/ a y))) b)))))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (/.f64 (+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y))) b)))
(* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (+ (* -1/2 (/ (log c) y)) (/ a y))) b)))))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (/.f64 (+.f64 (/.f64 a y) (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y))) b)))
(+ (/ a y) (/ (* (log c) (- b 1/2)) y))
(+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+ i (+ (/ a y) (/ (* (log c) (- b 1/2)) y)))
(+.f64 i (+.f64 (/.f64 a y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
i
(* i (+ 1 (+ (/ a (* i y)) (/ (* (log c) (- b 1/2)) (* i y)))))
(*.f64 i (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 a (*.f64 i y)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 i y)))))
(* i (+ 1 (+ (/ a (* i y)) (/ (* (log c) (- b 1/2)) (* i y)))))
(*.f64 i (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 a (*.f64 i y)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 i y)))))
(* i (+ 1 (+ (/ a (* i y)) (/ (* (log c) (- b 1/2)) (* i y)))))
(*.f64 i (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 a (*.f64 i y)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 i y)))))
i
(* -1 (* i (- (* -1 (/ (+ (/ a y) (/ (* (log c) (- b 1/2)) y)) i)) 1)))
(*.f64 i (+.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (/.f64 (-.f64 (-.f64 #s(literal 0 binary64) a) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y) i))))
(* -1 (* i (- (* -1 (/ (+ (/ a y) (/ (* (log c) (- b 1/2)) y)) i)) 1)))
(*.f64 i (+.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (/.f64 (-.f64 (-.f64 #s(literal 0 binary64) a) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y) i))))
(* -1 (* i (- (* -1 (/ (+ (/ a y) (/ (* (log c) (- b 1/2)) y)) i)) 1)))
(*.f64 i (+.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (/.f64 (-.f64 (-.f64 #s(literal 0 binary64) a) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y) i))))
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(/ a y)
(/.f64 a y)
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y)))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))
(+.f64 i (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))
(+.f64 i (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))
(+.f64 i (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y))
(+.f64 i (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (* -1/2 (/ (log c) y)))
(+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y))
(+ i (+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y)))
(+.f64 i (*.f64 (/.f64 (log.f64 c) y) (+.f64 b #s(literal -1/2 binary64))))
(+ i (+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y)))
(+.f64 i (*.f64 (/.f64 (log.f64 c) y) (+.f64 b #s(literal -1/2 binary64))))
(+ i (+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y)))
(+.f64 i (*.f64 (/.f64 (log.f64 c) y) (+.f64 b #s(literal -1/2 binary64))))
(/ (* b (log c)) y)
(/.f64 (*.f64 (log.f64 c) b) y)
(* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ i b) (/ (log c) y))))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 y b)) (/.f64 i b))))
(* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ i b) (/ (log c) y))))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 y b)) (/.f64 i b))))
(* b (+ (* -1/2 (/ (log c) (* b y))) (+ (/ i b) (/ (log c) y))))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 y b)) (/.f64 i b))))
(/ (* b (log c)) y)
(/.f64 (*.f64 (log.f64 c) b) y)
(* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (* -1/2 (/ (log c) y))) b)))))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (/.f64 (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y)) b)))
(* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (* -1/2 (/ (log c) y))) b)))))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (/.f64 (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y)) b)))
(* -1 (* b (+ (* -1 (/ (log c) y)) (* -1 (/ (+ i (* -1/2 (/ (log c) y))) b)))))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (/.f64 (+.f64 i (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y)) b)))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (+ (* i y) (* (log c) (- b 1/2))) y)
(/.f64 (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y)
(/ (+ (* i y) (* (log c) (- b 1/2))) y)
(/.f64 (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y)
(/ (+ (* i y) (* (log c) (- b 1/2))) y)
(/.f64 (+.f64 (*.f64 i y) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) y)
i
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
i
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
(+ i (/ (* (log c) (- b 1/2)) y))
(+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y)))
i
(* i (+ 1 (/ (* (log c) (- b 1/2)) (* i y))))
(*.f64 i (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 i y))))
(* i (+ 1 (/ (* (log c) (- b 1/2)) (* i y))))
(*.f64 i (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 i y))))
(* i (+ 1 (/ (* (log c) (- b 1/2)) (* i y))))
(*.f64 i (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 i y))))
i
(* -1 (* i (- (* -1 (/ (* (log c) (- b 1/2)) (* i y))) 1)))
(*.f64 i (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 i y))))
(* -1 (* i (- (* -1 (/ (* (log c) (- b 1/2)) (* i y))) 1)))
(*.f64 i (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 i y))))
(* -1 (* i (- (* -1 (/ (* (log c) (- b 1/2)) (* i y))) 1)))
(*.f64 i (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 i y))))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(* (pow i 2) y)
(*.f64 i (*.f64 i y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y))
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y))
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y))
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(* -1 (/ (* (log (/ 1 c)) (- b 1/2)) y))
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) y)
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(* -1/2 (/ (log c) y))
(/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) y)
(+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y))
(*.f64 (/.f64 (log.f64 c) y) (+.f64 b #s(literal -1/2 binary64)))
(+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y))
(*.f64 (/.f64 (log.f64 c) y) (+.f64 b #s(literal -1/2 binary64)))
(+ (* -1/2 (/ (log c) y)) (/ (* b (log c)) y))
(*.f64 (/.f64 (log.f64 c) y) (+.f64 b #s(literal -1/2 binary64)))
(/ (* b (log c)) y)
(/.f64 (*.f64 (log.f64 c) b) y)
(* b (+ (* -1/2 (/ (log c) (* b y))) (/ (log c) y)))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 y b))))
(* b (+ (* -1/2 (/ (log c) (* b y))) (/ (log c) y)))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 y b))))
(* b (+ (* -1/2 (/ (log c) (* b y))) (/ (log c) y)))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 y b))))
(/ (* b (log c)) y)
(/.f64 (*.f64 (log.f64 c) b) y)
(* -1 (* b (+ (* -1 (/ (log c) y)) (* 1/2 (/ (log c) (* b y))))))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 y b))))
(* -1 (* b (+ (* -1 (/ (log c) y)) (* 1/2 (/ (log c) (* b y))))))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 y b))))
(* -1 (* b (+ (* -1 (/ (log c) y)) (* 1/2 (/ (log c) (* b y))))))
(*.f64 b (+.f64 (/.f64 (log.f64 c) y) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 y b))))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(/ (* (log c) (- b 1/2)) y)
(*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* -1/2 (log c))
(*.f64 (log.f64 c) #s(literal -1/2 binary64))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))

eval196.0ms (1.5%)

Compiler

Compiled 47134 to 3224 computations (93.2% saved)

prune280.0ms (2.2%)

Pruning

40 alts after pruning (36 fresh and 4 done)

PrunedKeptTotal
New1330191349
Fresh61723
Picked325
Done022
Total1339401379
Accuracy
100.0%
Counts
1379 → 40
Alt Table
Click to see full alt table
StatusAccuracyProgram
2.0%
(/.f64 (/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z (*.f64 y i)))
0.3%
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
8.3%
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (*.f64 y i) y) i)) (-.f64 z (*.f64 y i)))
7.7%
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 (*.f64 i i) y))) (-.f64 z (*.f64 y i)))
3.0%
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
7.9%
(/.f64 (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i)))
3.0%
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
▶7.3%
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
4.7%
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
8.7%
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
▶3.6%
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
47.1%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
23.2%
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
50.6%
(+.f64 (/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 y i))
43.8%
(+.f64 (/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) a) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) a)) (*.f64 y i))
69.2%
(+.f64 (+.f64 (+.f64 (*.f64 a (/.f64 (*.f64 x (log.f64 y)) a)) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
61.0%
(+.f64 (+.f64 (+.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
▶76.5%
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
42.4%
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (/.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 b #s(literal 1/2 binary64)))) (*.f64 y i))
▶59.0%
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
36.8%
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
52.2%
(+.f64 (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 a #s(literal 1 binary64)))
33.1%
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
41.9%
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
69.2%
(+.f64 (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) a)) (+.f64 #s(literal 1 binary64) (/.f64 z a)))) (*.f64 y i))
✓47.2%
(+.f64 z (*.f64 y i))
45.6%
(+.f64 a (*.f64 y i))
3.5%
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
✓14.6%
(*.f64 (log.f64 c) b)
42.7%
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
15.5%
(*.f64 y (/.f64 a y))
39.3%
(*.f64 y (+.f64 (/.f64 a y) i))
37.7%
(*.f64 y (+.f64 i (/.f64 z y)))
67.8%
(*.f64 y (+.f64 i (+.f64 (*.f64 (log.f64 y) (/.f64 x y)) (+.f64 (+.f64 (/.f64 z y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) (+.f64 (/.f64 a y) (/.f64 t y))))))
33.7%
(*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
▶25.8%
(*.f64 y i)
18.4%
(*.f64 x (log.f64 y))
36.0%
(*.f64 i (+.f64 y (/.f64 z i)))
✓23.7%
z
✓21.8%
a
Compiler

Compiled 2057 to 1236 computations (39.9% saved)

simplify208.0ms (1.6%)

Algorithm
1×egg-herbie
Localize:

Found 17 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(+.f64 b #s(literal -1/2 binary64))
✓cost-diff0
(log.f64 c)
✓cost-diff0
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
✓cost-diff0
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
✓cost-diff0
(*.f64 z z)
✓cost-diff0
(+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))
✓cost-diff0
(/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))))
✓cost-diff128
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
✓cost-diff0
(*.f64 y i)
✓cost-diff0
(-.f64 z (*.f64 y i))
✓cost-diff0
(*.f64 z z)
✓cost-diff0
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
✓cost-diff0
(*.f64 y i)
✓cost-diff0
(+.f64 t z)
✓cost-diff0
(+.f64 a (+.f64 t z))
✓cost-diff0
(+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
✓cost-diff0
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
Rules
1934×+-lowering-+.f64
1934×+-lowering-+.f32
1836×fnmadd-define
1700×fma-lowering-fma.f32
1700×fma-lowering-fma.f64
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
035239
198208
2329204
3999204
43328204
54141204
65381204
08023204
Stop Event
1×iter limit
1×node limit
Calls
Call 1
Inputs
(+ (+ (+ a (+ t z)) (* (log c) (+ b -1/2))) (* x (log y)))
(+ (+ a (+ t z)) (* (log c) (+ b -1/2)))
(+ a (+ t z))
a
(+ t z)
t
z
(* (log c) (+ b -1/2))
(log c)
c
(+ b -1/2)
b
-1/2
(* x (log y))
x
(log y)
y
(* y i)
y
i
(/ (* z z) (- z (* y i)))
(* z z)
z
(- z (* y i))
(* y i)
y
i
(/ 1 (/ (+ (* z z) (* (* y i) (- (* y i) z))) (+ (* (* y i) (* y (* i (* y i)))) (* z (* z z)))))
1
(/ (+ (* z z) (* (* y i) (- (* y i) z))) (+ (* (* y i) (* y (* i (* y i)))) (* z (* z z))))
(+ (* z z) (* (* y i) (- (* y i) z)))
(* z z)
z
(* (* y i) (- (* y i) z))
(* y i)
y
i
(- (* y i) z)
(+ (* (* y i) (* y (* i (* y i)))) (* z (* z z)))
(* (* y i) (* y (* i (* y i))))
(* y (* i (* y i)))
(* i (* y i))
(* z (* z z))
(+ (* (log c) (+ b -1/2)) (+ a z))
(* (log c) (+ b -1/2))
(log c)
c
(+ b -1/2)
b
-1/2
(+ a z)
a
z
Outputs
(+ (+ (+ a (+ t z)) (* (log c) (+ b -1/2))) (* x (log y)))
(+.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))
(+ (+ a (+ t z)) (* (log c) (+ b -1/2)))
(+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ a (+ t z))
(+.f64 a (+.f64 t z))
a
(+ t z)
(+.f64 t z)
t
z
(* (log c) (+ b -1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(log c)
(log.f64 c)
c
(+ b -1/2)
(+.f64 b #s(literal -1/2 binary64))
b
-1/2
#s(literal -1/2 binary64)
(* x (log y))
(*.f64 x (log.f64 y))
x
(log y)
(log.f64 y)
y
(* y i)
(*.f64 y i)
y
i
(/ (* z z) (- z (* y i)))
(*.f64 z (/.f64 z (-.f64 z (*.f64 y i))))
(* z z)
(*.f64 z z)
z
(- z (* y i))
(-.f64 z (*.f64 y i))
(* y i)
(*.f64 y i)
y
i
(/ 1 (/ (+ (* z z) (* (* y i) (- (* y i) z))) (+ (* (* y i) (* y (* i (* y i)))) (* z (* z z)))))
(/.f64 (+.f64 (*.f64 i (*.f64 y (*.f64 i (*.f64 y (*.f64 y i))))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (-.f64 (*.f64 y i) z)))))
1
#s(literal 1 binary64)
(/ (+ (* z z) (* (* y i) (- (* y i) z))) (+ (* (* y i) (* y (* i (* y i)))) (* z (* z z))))
(/.f64 (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 i (*.f64 y (*.f64 i (*.f64 y (*.f64 y i))))) (*.f64 z (*.f64 z z))))
(+ (* z z) (* (* y i) (- (* y i) z)))
(+.f64 (*.f64 z z) (*.f64 y (*.f64 i (-.f64 (*.f64 y i) z))))
(* z z)
(*.f64 z z)
z
(* (* y i) (- (* y i) z))
(*.f64 y (*.f64 i (-.f64 (*.f64 y i) z)))
(* y i)
(*.f64 y i)
y
i
(- (* y i) z)
(-.f64 (*.f64 y i) z)
(+ (* (* y i) (* y (* i (* y i)))) (* z (* z z)))
(+.f64 (*.f64 i (*.f64 y (*.f64 i (*.f64 y (*.f64 y i))))) (*.f64 z (*.f64 z z)))
(* (* y i) (* y (* i (* y i))))
(*.f64 i (*.f64 y (*.f64 i (*.f64 y (*.f64 y i)))))
(* y (* i (* y i)))
(*.f64 i (*.f64 y (*.f64 y i)))
(* i (* y i))
(*.f64 y (*.f64 i i))
(* z (* z z))
(*.f64 z (*.f64 z z))
(+ (* (log c) (+ b -1/2)) (+ a z))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(* (log c) (+ b -1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(log c)
(log.f64 c)
c
(+ b -1/2)
(+.f64 b #s(literal -1/2 binary64))
b
-1/2
#s(literal -1/2 binary64)
(+ a z)
(+.f64 a z)
a
z

localize225.0ms (1.7%)

Localize:

Found 17 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(+.f64 a z)
✓accuracy100.0%
(log.f64 c)
✓accuracy100.0%
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
✓accuracy99.8%
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
✓accuracy93.8%
(*.f64 y (*.f64 i (*.f64 y i)))
✓accuracy92.3%
(*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))
✓accuracy91.7%
(+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))
✓accuracy25.1%
(/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))))
✓accuracy100.0%
(*.f64 z z)
✓accuracy100.0%
(*.f64 y i)
✓accuracy100.0%
(-.f64 z (*.f64 y i))
✓accuracy63.5%
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
✓accuracy100.0%
(*.f64 y i)
✓accuracy100.0%
(+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
✓accuracy100.0%
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
✓accuracy99.8%
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
✓accuracy99.6%
(*.f64 x (log.f64 y))
Results
179.0ms256×0valid
Compiler

Compiled 274 to 36 computations (86.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 65.0ms
ival-div: 21.0ms (32.4% of total)
ival-mult: 15.0ms (23.2% of total)
ival-add: 13.0ms (20.1% of total)
ival-log: 8.0ms (12.4% of total)
ival-sub: 7.0ms (10.8% of total)
const: 1.0ms (1.5% of total)
backward-pass: 0.0ms (0% of total)

series39.0ms (0.3%)

Counts
20 → 660
Calls
Call 1
Inputs
#<alt (+ (+ (+ a (+ t z)) (* (log c) (+ b -1/2))) (* x (log y)))>
#<alt (+ (+ a (+ t z)) (* (log c) (+ b -1/2)))>
#<alt (+ a (+ t z))>
#<alt (+ t z)>
#<alt (* y i)>
#<alt (/ (* z z) (- z (* y i)))>
#<alt (* z z)>
#<alt (- z (* y i))>
#<alt (/ 1 (/ (+ (* z z) (* (* y i) (- (* y i) z))) (+ (* (* y i) (* y (* i (* y i)))) (* z (* z z)))))>
#<alt (/ (+ (* z z) (* (* y i) (- (* y i) z))) (+ (* (* y i) (* y (* i (* y i)))) (* z (* z z))))>
#<alt (+ (* z z) (* (* y i) (- (* y i) z)))>
#<alt (+ (* (log c) (+ b -1/2)) (+ a z))>
#<alt (* (log c) (+ b -1/2))>
#<alt (log c)>
#<alt (+ b -1/2)>
#<alt (* x (log y))>
#<alt (+ (* (* y i) (* y (* i (* y i)))) (* z (* z z)))>
#<alt (* (* y i) (- (* y i) z))>
#<alt (* y (* i (* y i)))>
#<alt (+ a z)>
Outputs
#<alt (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt a>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))>
#<alt (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt t>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))>
#<alt t>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))>
#<alt (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt z>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (* x (log y))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))>
#<alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))>
#<alt (* x (log y))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))>
#<alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))>
#<alt (+ t (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt a>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))>
#<alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (* (log c) (- b 1/2)))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (* (log c) (- b 1/2)))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t (+ z (* (log c) (- b 1/2)))) a)) 1)))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt t>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* (log c) (- b 1/2)) t)))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* (log c) (- b 1/2)) t)))))>
#<alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* (log c) (- b 1/2)) t)))))>
#<alt t>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) t)) 1)))>
#<alt (+ a (+ t (* (log c) (- b 1/2))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt z>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* (log c) (- b 1/2)) z)))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* (log c) (- b 1/2)) z)))))>
#<alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* (log c) (- b 1/2)) z)))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (* (log c) (- b 1/2)))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (* (log c) (- b 1/2)))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (+ t (* (log c) (- b 1/2)))) z)) 1)))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* (log c) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* -1 (* (log (/ 1 c)) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (* -1 (* (log (/ 1 c)) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (* -1 (* (log (/ 1 c)) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (* -1 (* (log (/ 1 c)) (- b 1/2))))))>
#<alt (+ a (+ t (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))>
#<alt (+ a (+ t (+ z (* -1/2 (log c)))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (* b (log c))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (* b (log c))))))>
#<alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (* b (log c))))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (/ z b))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (/ z b))))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (/ z b))))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (* -1/2 (log c))))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (* -1/2 (log c))))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (* -1/2 (log c))))) b)))))>
#<alt (+ t z)>
#<alt (+ a (+ t z))>
#<alt (+ a (+ t z))>
#<alt (+ a (+ t z))>
#<alt a>
#<alt (* a (+ 1 (+ (/ t a) (/ z a))))>
#<alt (* a (+ 1 (+ (/ t a) (/ z a))))>
#<alt (* a (+ 1 (+ (/ t a) (/ z a))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (+ t z) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t z) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ t z) a)) 1)))>
#<alt (+ a z)>
#<alt (+ a (+ t z))>
#<alt (+ a (+ t z))>
#<alt (+ a (+ t z))>
#<alt t>
#<alt (* t (+ 1 (+ (/ a t) (/ z t))))>
#<alt (* t (+ 1 (+ (/ a t) (/ z t))))>
#<alt (* t (+ 1 (+ (/ a t) (/ z t))))>
#<alt t>
#<alt (* -1 (* t (- (* -1 (/ (+ a z) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a z) t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ (+ a z) t)) 1)))>
#<alt (+ a t)>
#<alt (+ a (+ t z))>
#<alt (+ a (+ t z))>
#<alt (+ a (+ t z))>
#<alt z>
#<alt (* z (+ 1 (+ (/ a z) (/ t z))))>
#<alt (* z (+ 1 (+ (/ a z) (/ t z))))>
#<alt (* z (+ 1 (+ (/ a z) (/ t z))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ a t) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a t) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a t) z)) 1)))>
#<alt z>
#<alt (+ t z)>
#<alt (+ t z)>
#<alt (+ t z)>
#<alt t>
#<alt (* t (+ 1 (/ z t)))>
#<alt (* t (+ 1 (/ z t)))>
#<alt (* t (+ 1 (/ z t)))>
#<alt t>
#<alt (* -1 (* t (- (* -1 (/ z t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ z t)) 1)))>
#<alt (* -1 (* t (- (* -1 (/ z t)) 1)))>
#<alt t>
#<alt (+ t z)>
#<alt (+ t z)>
#<alt (+ t z)>
#<alt z>
#<alt (* z (+ 1 (/ t z)))>
#<alt (* z (+ 1 (/ t z)))>
#<alt (* z (+ 1 (/ t z)))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ t z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ t z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ t z)) 1)))>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* i y)>
#<alt (* -1 (/ (pow z 2) (* i y)))>
#<alt (* (pow z 2) (- (* -1 (/ z (* (pow i 2) (pow y 2)))) (/ 1 (* i y))))>
#<alt (* (pow z 2) (- (* z (- (* -1 (/ z (* (pow i 3) (pow y 3)))) (/ 1 (* (pow i 2) (pow y 2))))) (/ 1 (* i y))))>
#<alt (* (pow z 2) (- (* z (- (* z (- (* -1 (/ z (* (pow i 4) (pow y 4)))) (/ 1 (* (pow i 3) (pow y 3))))) (/ 1 (* (pow i 2) (pow y 2))))) (/ 1 (* i y))))>
#<alt z>
#<alt (* z (+ 1 (/ (* i y) z)))>
#<alt (* z (- (+ 1 (/ (* (pow i 2) (pow y 2)) (pow z 2))) (* -1 (/ (* i y) z))))>
#<alt (* z (- (+ 1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) (+ (* -1 (/ (* i y) z)) (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2))))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (* i y) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (- (/ (* (pow i 2) (pow y 2)) z) (* -1 (* i y))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (- (* -1 (/ (- (* -1 (/ (* (pow i 3) (pow y 3)) z)) (* (pow i 2) (pow y 2))) z)) (* -1 (* i y))) z)) 1)))>
#<alt z>
#<alt (+ z (* i y))>
#<alt (+ z (* y (- (/ (* (pow i 2) y) z) (* -1 i))))>
#<alt (+ z (* y (- (* y (- (/ (* (pow i 3) y) (pow z 2)) (* -1 (/ (pow i 2) z)))) (* -1 i))))>
#<alt (* -1 (/ (pow z 2) (* i y)))>
#<alt (/ (+ (* -1 (/ (pow z 2) i)) (* -1 (/ (pow z 3) (* (pow i 2) y)))) y)>
#<alt (/ (- (+ (* -1 (/ (pow z 2) i)) (* -1 (/ (pow z 4) (* (pow i 3) (pow y 2))))) (/ (pow z 3) (* (pow i 2) y))) y)>
#<alt (/ (- (+ (* -1 (/ (pow z 2) i)) (* -1 (/ (pow z 5) (* (pow i 4) (pow y 3))))) (+ (/ (pow z 3) (* (pow i 2) y)) (/ (pow z 4) (* (pow i 3) (pow y 2))))) y)>
#<alt (* -1 (/ (pow z 2) (* i y)))>
#<alt (* -1 (/ (+ (/ (pow z 2) i) (/ (pow z 3) (* (pow i 2) y))) y))>
#<alt (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (pow z 4) (* (pow i 3) y))) (/ (pow z 3) (pow i 2))) y)) (/ (pow z 2) i)) y))>
#<alt (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (pow z 5) (* (pow i 4) y)) (* -1 (/ (pow z 4) (pow i 3)))) y)) (/ (pow z 3) (pow i 2))) y)) (/ (pow z 2) i)) y))>
#<alt z>
#<alt (+ z (* i y))>
#<alt (+ z (* i (- (/ (* i (pow y 2)) z) (* -1 y))))>
#<alt (+ z (* i (- (* i (- (/ (* i (pow y 3)) (pow z 2)) (* -1 (/ (pow y 2) z)))) (* -1 y))))>
#<alt (* -1 (/ (pow z 2) (* i y)))>
#<alt (/ (+ (* -1 (/ (pow z 2) y)) (* -1 (/ (pow z 3) (* i (pow y 2))))) i)>
#<alt (/ (- (+ (* -1 (/ (pow z 2) y)) (* -1 (/ (pow z 4) (* (pow i 2) (pow y 3))))) (/ (pow z 3) (* i (pow y 2)))) i)>
#<alt (/ (- (+ (* -1 (/ (pow z 2) y)) (* -1 (/ (pow z 5) (* (pow i 3) (pow y 4))))) (+ (/ (pow z 3) (* i (pow y 2))) (/ (pow z 4) (* (pow i 2) (pow y 3))))) i)>
#<alt (* -1 (/ (pow z 2) (* i y)))>
#<alt (* -1 (/ (+ (/ (pow z 2) y) (/ (pow z 3) (* i (pow y 2)))) i))>
#<alt (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (pow z 4) (* i (pow y 3)))) (/ (pow z 3) (pow y 2))) i)) (/ (pow z 2) y)) i))>
#<alt (* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (pow z 5) (* i (pow y 4))) (* -1 (/ (pow z 4) (pow y 3)))) i)) (/ (pow z 3) (pow y 2))) i)) (/ (pow z 2) y)) i))>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (pow z 2)>
#<alt (* -1 (* i y))>
#<alt (- z (* i y))>
#<alt (- z (* i y))>
#<alt (- z (* i y))>
#<alt z>
#<alt (* z (+ 1 (* -1 (/ (* i y) z))))>
#<alt (* z (+ 1 (* -1 (/ (* i y) z))))>
#<alt (* z (+ 1 (* -1 (/ (* i y) z))))>
#<alt z>
#<alt (* -1 (* z (- (/ (* i y) z) 1)))>
#<alt (* -1 (* z (- (/ (* i y) z) 1)))>
#<alt (* -1 (* z (- (/ (* i y) z) 1)))>
#<alt z>
#<alt (+ z (* -1 (* i y)))>
#<alt (+ z (* -1 (* i y)))>
#<alt (+ z (* -1 (* i y)))>
#<alt (* -1 (* i y))>
#<alt (* y (- (/ z y) i))>
#<alt (* y (- (/ z y) i))>
#<alt (* y (- (/ z y) i))>
#<alt (* -1 (* i y))>
#<alt (* -1 (* y (- (* -1 (/ z y)) (* -1 i))))>
#<alt (* -1 (* y (- (* -1 (/ z y)) (* -1 i))))>
#<alt (* -1 (* y (- (* -1 (/ z y)) (* -1 i))))>
#<alt z>
#<alt (+ z (* -1 (* i y)))>
#<alt (+ z (* -1 (* i y)))>
#<alt (+ z (* -1 (* i y)))>
#<alt (* -1 (* i y))>
#<alt (* i (- (/ z i) y))>
#<alt (* i (- (/ z i) y))>
#<alt (* i (- (/ z i) y))>
#<alt (* -1 (* i y))>
#<alt (* -1 (* i (- (* -1 (/ z i)) (* -1 y))))>
#<alt (* -1 (* i (- (* -1 (/ z i)) (* -1 y))))>
#<alt (* -1 (* i (- (* -1 (/ z i)) (* -1 y))))>
#<alt (* i y)>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt (+ z (* i y))>
#<alt z>
#<alt (* z (+ 1 (/ (* i y) z)))>
#<alt (* z (- (+ 1 (* -1 (/ (+ (* -1 (* (pow i 2) (pow y 2))) (* (pow i 2) (pow y 2))) (pow z 2)))) (* -1 (/ (* i y) z))))>
#<alt (* z (- (+ 1 (* -1 (/ (* i (* y (+ (* -1 (* (pow i 2) (pow y 2))) (* (pow i 2) (pow y 2))))) (pow z 3)))) (+ (* -1 (/ (* i y) z)) (+ (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2))) (/ (* (pow i 2) (pow y 2)) (pow z 2))))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (* i y) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (- (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (/ (* (pow i 2) (pow y 2)) z)) (* -1 (* i y))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (- (* -1 (/ (- (* -1 (/ (* i (* y (+ (* -1 (* (pow i 2) (pow y 2))) (* (pow i 2) (pow y 2))))) z)) (+ (* -1 (* (pow i 2) (pow y 2))) (* (pow i 2) (pow y 2)))) z)) (* -1 (* i y))) z)) 1)))>
#<alt z>
#<alt (+ z (* i y))>
#<alt (+ z (* y (- (* -1 (* y (+ (* -1 (/ (pow i 2) z)) (/ (pow i 2) z)))) (* -1 i))))>
#<alt (+ z (* y (- (* y (- (* -1 (/ (* i (* y (+ (* -1 (/ (pow i 2) z)) (/ (pow i 2) z)))) z)) (+ (* -1 (/ (pow i 2) z)) (/ (pow i 2) z)))) (* -1 i))))>
#<alt (* i y)>
#<alt (* y (+ i (/ z y)))>
#<alt (* y (- (+ i (* -1 (/ (+ (* -1 (/ (pow z 2) i)) (/ (pow z 2) i)) (pow y 2)))) (* -1 (/ z y))))>
#<alt (* y (- (+ i (* -1 (/ (* z (+ (* -1 (/ (pow z 2) i)) (/ (pow z 2) i))) (* i (pow y 3))))) (+ (* -1 (/ z y)) (+ (* -1 (/ (pow z 2) (* i (pow y 2)))) (/ (pow z 2) (* i (pow y 2)))))))>
#<alt (* i y)>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (- (+ (* -1 (/ (pow z 2) (* i y))) (/ (pow z 2) (* i y))) (* -1 z)) y)))))>
#<alt (* -1 (* y (+ (* -1 i) (* -1 (/ (- (* -1 (/ (- (* -1 (/ (* z (+ (* -1 (/ (pow z 2) i)) (/ (pow z 2) i))) (* i y))) (+ (* -1 (/ (pow z 2) i)) (/ (pow z 2) i))) y)) (* -1 z)) y)))))>
#<alt z>
#<alt (+ z (* i y))>
#<alt (+ z (* i (- (* -1 (* i (+ (* -1 (/ (pow y 2) z)) (/ (pow y 2) z)))) (* -1 y))))>
#<alt (+ z (* i (- (* i (- (* -1 (/ (* i (* y (+ (* -1 (/ (pow y 2) z)) (/ (pow y 2) z)))) z)) (+ (* -1 (/ (pow y 2) z)) (/ (pow y 2) z)))) (* -1 y))))>
#<alt (* i y)>
#<alt (* i (+ y (/ z i)))>
#<alt (* i (- (+ y (* -1 (/ (+ (* -1 (/ (pow z 2) y)) (/ (pow z 2) y)) (pow i 2)))) (* -1 (/ z i))))>
#<alt (* i (- (+ y (* -1 (/ (* z (+ (* -1 (/ (pow z 2) y)) (/ (pow z 2) y))) (* (pow i 3) y)))) (+ (* -1 (/ z i)) (+ (* -1 (/ (pow z 2) (* (pow i 2) y))) (/ (pow z 2) (* (pow i 2) y))))))>
#<alt (* i y)>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (- (+ (* -1 (/ (pow z 2) (* i y))) (/ (pow z 2) (* i y))) (* -1 z)) i)))))>
#<alt (* -1 (* i (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (* -1 (/ (* z (+ (* -1 (/ (pow z 2) y)) (/ (pow z 2) y))) (* i y))) (+ (* -1 (/ (pow z 2) y)) (/ (pow z 2) y))) i)) (* -1 z)) i)))))>
#<alt (/ 1 (* i y))>
#<alt (+ (* -1 (/ z (* (pow i 2) (pow y 2)))) (/ 1 (* i y)))>
#<alt (+ (* z (- (/ z (* (pow i 3) (pow y 3))) (/ 1 (* (pow i 2) (pow y 2))))) (/ 1 (* i y)))>
#<alt (+ (* z (- (* z (+ (* -1 (/ z (* (pow i 4) (pow y 4)))) (/ 1 (* (pow i 3) (pow y 3))))) (/ 1 (* (pow i 2) (pow y 2))))) (/ 1 (* i y)))>
#<alt (/ 1 z)>
#<alt (/ (+ 1 (* -1 (/ (* i y) z))) z)>
#<alt (/ (+ 1 (+ (* -1 (/ (* i y) z)) (/ (* (pow i 2) (pow y 2)) (pow z 2)))) z)>
#<alt (/ (+ 1 (+ (* -1 (/ (* i y) z)) (+ (* -1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) (/ (* (pow i 2) (pow y 2)) (pow z 2))))) z)>
#<alt (/ 1 z)>
#<alt (* -1 (/ (- (/ (* i y) z) 1) z))>
#<alt (* -1 (/ (- (* -1 (/ (+ (* -1 (* i y)) (/ (* (pow i 2) (pow y 2)) z)) z)) 1) z))>
#<alt (* -1 (/ (- (* -1 (/ (+ (* -1 (* i y)) (* -1 (/ (+ (* -1 (* (pow i 2) (pow y 2))) (/ (* (pow i 3) (pow y 3)) z)) z))) z)) 1) z))>
#<alt (/ 1 z)>
#<alt (+ (* -1 (/ (* i y) (pow z 2))) (/ 1 z))>
#<alt (+ (* y (+ (* -1 (/ i (pow z 2))) (/ (* (pow i 2) y) (pow z 3)))) (/ 1 z))>
#<alt (+ (* y (+ (* -1 (/ i (pow z 2))) (* y (+ (* -1 (/ (* (pow i 3) y) (pow z 4))) (/ (pow i 2) (pow z 3)))))) (/ 1 z))>
#<alt (/ 1 (* i y))>
#<alt (/ (+ (* -1 (/ z (* (pow i 2) y))) (/ 1 i)) y)>
#<alt (/ (+ (* -1 (/ z (* (pow i 2) y))) (+ (/ 1 i) (/ (pow z 2) (* (pow i 3) (pow y 2))))) y)>
#<alt (/ (+ (* -1 (/ z (* (pow i 2) y))) (+ (* -1 (/ (pow z 3) (* (pow i 4) (pow y 3)))) (+ (/ 1 i) (/ (pow z 2) (* (pow i 3) (pow y 2)))))) y)>
#<alt (/ 1 (* i y))>
#<alt (* -1 (/ (- (/ z (* (pow i 2) y)) (/ 1 i)) y))>
#<alt (* -1 (/ (- (* -1 (/ (+ (* -1 (/ z (pow i 2))) (/ (pow z 2) (* (pow i 3) y))) y)) (/ 1 i)) y))>
#<alt (* -1 (/ (- (* -1 (/ (+ (* -1 (/ z (pow i 2))) (* -1 (/ (+ (* -1 (/ (pow z 2) (pow i 3))) (/ (pow z 3) (* (pow i 4) y))) y))) y)) (/ 1 i)) y))>
#<alt (/ 1 z)>
#<alt (+ (* -1 (/ (* i y) (pow z 2))) (/ 1 z))>
#<alt (+ (* i (+ (* -1 (/ y (pow z 2))) (/ (* i (pow y 2)) (pow z 3)))) (/ 1 z))>
#<alt (+ (* i (+ (* -1 (/ y (pow z 2))) (* i (+ (* -1 (/ (* i (pow y 3)) (pow z 4))) (/ (pow y 2) (pow z 3)))))) (/ 1 z))>
#<alt (/ 1 (* i y))>
#<alt (/ (+ (* -1 (/ z (* i (pow y 2)))) (/ 1 y)) i)>
#<alt (/ (+ (* -1 (/ z (* i (pow y 2)))) (+ (/ 1 y) (/ (pow z 2) (* (pow i 2) (pow y 3))))) i)>
#<alt (/ (+ (* -1 (/ z (* i (pow y 2)))) (+ (* -1 (/ (pow z 3) (* (pow i 3) (pow y 4)))) (+ (/ 1 y) (/ (pow z 2) (* (pow i 2) (pow y 3)))))) i)>
#<alt (/ 1 (* i y))>
#<alt (* -1 (/ (- (/ z (* i (pow y 2))) (/ 1 y)) i))>
#<alt (* -1 (/ (- (* -1 (/ (+ (* -1 (/ z (pow y 2))) (/ (pow z 2) (* i (pow y 3)))) i)) (/ 1 y)) i))>
#<alt (* -1 (/ (- (* -1 (/ (+ (* -1 (/ z (pow y 2))) (* -1 (/ (+ (* -1 (/ (pow z 2) (pow y 3))) (/ (pow z 3) (* i (pow y 4)))) i))) i)) (/ 1 y)) i))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (+ (* -1 (* i (* y z))) (* (pow i 2) (pow y 2)))>
#<alt (+ (* z (+ z (* -1 (* i y)))) (* (pow i 2) (pow y 2)))>
#<alt (+ (* z (+ z (* -1 (* i y)))) (* (pow i 2) (pow y 2)))>
#<alt (pow z 2)>
#<alt (* (pow z 2) (+ 1 (* -1 (/ (* i y) z))))>
#<alt (* (pow z 2) (+ 1 (+ (* -1 (/ (* i y) z)) (/ (* (pow i 2) (pow y 2)) (pow z 2)))))>
#<alt (* (pow z 2) (+ 1 (+ (* -1 (/ (* i y) z)) (/ (* (pow i 2) (pow y 2)) (pow z 2)))))>
#<alt (pow z 2)>
#<alt (* (pow z 2) (+ 1 (* -1 (/ (* i y) z))))>
#<alt (* (pow z 2) (+ 1 (* -1 (/ (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y)) z))))>
#<alt (* (pow z 2) (+ 1 (* -1 (/ (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y)) z))))>
#<alt (pow z 2)>
#<alt (+ (* -1 (* i (* y z))) (pow z 2))>
#<alt (+ (* y (+ (* -1 (* i z)) (* (pow i 2) y))) (pow z 2))>
#<alt (+ (* y (+ (* -1 (* i z)) (* (pow i 2) y))) (pow z 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))>
#<alt (* (pow y 2) (+ (* -1 (/ (* i z) y)) (+ (/ (pow z 2) (pow y 2)) (pow i 2))))>
#<alt (* (pow y 2) (+ (* -1 (/ (* i z) y)) (+ (/ (pow z 2) (pow y 2)) (pow i 2))))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))>
#<alt (* (pow y 2) (+ (* -1 (/ (+ (* -1 (/ (pow z 2) y)) (* i z)) y)) (pow i 2)))>
#<alt (* (pow y 2) (+ (* -1 (/ (+ (* -1 (/ (pow z 2) y)) (* i z)) y)) (pow i 2)))>
#<alt (pow z 2)>
#<alt (+ (* -1 (* i (* y z))) (pow z 2))>
#<alt (+ (* i (+ (* -1 (* y z)) (* i (pow y 2)))) (pow z 2))>
#<alt (+ (* i (+ (* -1 (* y z)) (* i (pow y 2)))) (pow z 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))>
#<alt (* (pow i 2) (+ (* -1 (/ (* y z) i)) (+ (/ (pow z 2) (pow i 2)) (pow y 2))))>
#<alt (* (pow i 2) (+ (* -1 (/ (* y z) i)) (+ (/ (pow z 2) (pow i 2)) (pow y 2))))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))>
#<alt (* (pow i 2) (+ (* -1 (/ (+ (* -1 (/ (pow z 2) i)) (* y z)) i)) (pow y 2)))>
#<alt (* (pow i 2) (+ (* -1 (/ (+ (* -1 (/ (pow z 2) i)) (* y z)) i)) (pow y 2)))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))>
#<alt (+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))>
#<alt (+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))>
#<alt (+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))>
#<alt (+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))>
#<alt (+ a (+ z (* -1/2 (log c))))>
#<alt (+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))>
#<alt (+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))>
#<alt (+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))>
#<alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))>
#<alt (+ z (* (log c) (- b 1/2)))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt a>
#<alt (* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))>
#<alt (* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))>
#<alt (* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))>
#<alt (+ a (* (log c) (- b 1/2)))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt (+ a (+ z (* (log c) (- b 1/2))))>
#<alt z>
#<alt (* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))>
#<alt (* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))>
#<alt (* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* (log c) (- b 1/2))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* -1 (* (log (/ 1 c)) (- b 1/2)))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))>
#<alt (* -1/2 (log c))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (+ (* -1/2 (log c)) (* b (log c)))>
#<alt (* b (log c))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (+ (log c) (* -1/2 (/ (log c) b))))>
#<alt (* b (log c))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))>
#<alt (log c)>
#<alt (log c)>
#<alt (log c)>
#<alt (log c)>
#<alt (* -1 (log (/ 1 c)))>
#<alt (* -1 (log (/ 1 c)))>
#<alt (* -1 (log (/ 1 c)))>
#<alt (* -1 (log (/ 1 c)))>
#<alt (+ (log -1) (* -1 (log (/ -1 c))))>
#<alt (+ (log -1) (* -1 (log (/ -1 c))))>
#<alt (+ (log -1) (* -1 (log (/ -1 c))))>
#<alt (+ (log -1) (* -1 (log (/ -1 c))))>
#<alt -1/2>
#<alt (- b 1/2)>
#<alt (- b 1/2)>
#<alt (- b 1/2)>
#<alt b>
#<alt (* b (- 1 (* 1/2 (/ 1 b))))>
#<alt (* b (- 1 (* 1/2 (/ 1 b))))>
#<alt (* b (- 1 (* 1/2 (/ 1 b))))>
#<alt b>
#<alt (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))>
#<alt (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))>
#<alt (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* x (log y))>
#<alt (* -1 (* x (log (/ 1 y))))>
#<alt (* -1 (* x (log (/ 1 y))))>
#<alt (* -1 (* x (log (/ 1 y))))>
#<alt (* -1 (* x (log (/ 1 y))))>
#<alt (* x (+ (log -1) (* -1 (log (/ -1 y)))))>
#<alt (* x (+ (log -1) (* -1 (log (/ -1 y)))))>
#<alt (* x (+ (log -1) (* -1 (log (/ -1 y)))))>
#<alt (* x (+ (log -1) (* -1 (log (/ -1 y)))))>
#<alt (pow z 3)>
#<alt (+ (* (pow i 3) (pow y 3)) (pow z 3))>
#<alt (+ (* (pow i 3) (pow y 3)) (pow z 3))>
#<alt (+ (* (pow i 3) (pow y 3)) (pow z 3))>
#<alt (* (pow i 3) (pow y 3))>
#<alt (* (pow y 3) (+ (/ (pow z 3) (pow y 3)) (pow i 3)))>
#<alt (* (pow y 3) (+ (/ (pow z 3) (pow y 3)) (pow i 3)))>
#<alt (* (pow y 3) (+ (/ (pow z 3) (pow y 3)) (pow i 3)))>
#<alt (* (pow i 3) (pow y 3))>
#<alt (* -1 (* (pow y 3) (+ (* -1 (/ (pow z 3) (pow y 3))) (* -1 (pow i 3)))))>
#<alt (* -1 (* (pow y 3) (+ (* -1 (/ (pow z 3) (pow y 3))) (* -1 (pow i 3)))))>
#<alt (* -1 (* (pow y 3) (+ (* -1 (/ (pow z 3) (pow y 3))) (* -1 (pow i 3)))))>
#<alt (pow z 3)>
#<alt (+ (* (pow i 3) (pow y 3)) (pow z 3))>
#<alt (+ (* (pow i 3) (pow y 3)) (pow z 3))>
#<alt (+ (* (pow i 3) (pow y 3)) (pow z 3))>
#<alt (* (pow i 3) (pow y 3))>
#<alt (* (pow i 3) (+ (/ (pow z 3) (pow i 3)) (pow y 3)))>
#<alt (* (pow i 3) (+ (/ (pow z 3) (pow i 3)) (pow y 3)))>
#<alt (* (pow i 3) (+ (/ (pow z 3) (pow i 3)) (pow y 3)))>
#<alt (* (pow i 3) (pow y 3))>
#<alt (* -1 (* (pow i 3) (+ (* -1 (/ (pow z 3) (pow i 3))) (* -1 (pow y 3)))))>
#<alt (* -1 (* (pow i 3) (+ (* -1 (/ (pow z 3) (pow i 3))) (* -1 (pow y 3)))))>
#<alt (* -1 (* (pow i 3) (+ (* -1 (/ (pow z 3) (pow i 3))) (* -1 (pow y 3)))))>
#<alt (* (pow i 3) (pow y 3))>
#<alt (+ (* (pow i 3) (pow y 3)) (pow z 3))>
#<alt (+ (* (pow i 3) (pow y 3)) (pow z 3))>
#<alt (+ (* (pow i 3) (pow y 3)) (pow z 3))>
#<alt (pow z 3)>
#<alt (* (pow z 3) (+ 1 (/ (* (pow i 3) (pow y 3)) (pow z 3))))>
#<alt (* (pow z 3) (+ 1 (/ (* (pow i 3) (pow y 3)) (pow z 3))))>
#<alt (* (pow z 3) (+ 1 (/ (* (pow i 3) (pow y 3)) (pow z 3))))>
#<alt (pow z 3)>
#<alt (* -1 (* (pow z 3) (- (* -1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) 1)))>
#<alt (* -1 (* (pow z 3) (- (* -1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) 1)))>
#<alt (* -1 (* (pow z 3) (- (* -1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) 1)))>
#<alt (* -1 (* i (* y z)))>
#<alt (* y (+ (* -1 (* i z)) (* (pow i 2) y)))>
#<alt (* y (+ (* -1 (* i z)) (* (pow i 2) y)))>
#<alt (* y (+ (* -1 (* i z)) (* (pow i 2) y)))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))>
#<alt (* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))>
#<alt (* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))>
#<alt (* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))>
#<alt (* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))>
#<alt (* -1 (* i (* y z)))>
#<alt (* i (+ (* -1 (* y z)) (* i (pow y 2))))>
#<alt (* i (+ (* -1 (* y z)) (* i (pow y 2))))>
#<alt (* i (+ (* -1 (* y z)) (* i (pow y 2))))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))>
#<alt (* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))>
#<alt (* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))>
#<alt (* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))>
#<alt (* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (+ (* -1 (* i (* y z))) (* (pow i 2) (pow y 2)))>
#<alt (+ (* -1 (* i (* y z))) (* (pow i 2) (pow y 2)))>
#<alt (+ (* -1 (* i (* y z))) (* (pow i 2) (pow y 2)))>
#<alt (* -1 (* i (* y z)))>
#<alt (* z (+ (* -1 (* i y)) (/ (* (pow i 2) (pow y 2)) z)))>
#<alt (* z (+ (* -1 (* i y)) (/ (* (pow i 2) (pow y 2)) z)))>
#<alt (* z (+ (* -1 (* i y)) (/ (* (pow i 2) (pow y 2)) z)))>
#<alt (* -1 (* i (* y z)))>
#<alt (* -1 (* z (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y))))>
#<alt (* -1 (* z (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y))))>
#<alt (* -1 (* z (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y))))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt (* (pow i 2) (pow y 2))>
#<alt z>
#<alt (+ a z)>
#<alt (+ a z)>
#<alt (+ a z)>
#<alt a>
#<alt (* a (+ 1 (/ z a)))>
#<alt (* a (+ 1 (/ z a)))>
#<alt (* a (+ 1 (/ z a)))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ z a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ z a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ z a)) 1)))>
#<alt a>
#<alt (+ a z)>
#<alt (+ a z)>
#<alt (+ a z)>
#<alt z>
#<alt (* z (+ 1 (/ a z)))>
#<alt (* z (+ 1 (/ a z)))>
#<alt (* z (+ 1 (/ a z)))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ a z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ a z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ a z)) 1)))>
Calls

165 calls:

TimeVariablePointExpression
4.0ms
i
@0
(* (* y i) (- (* y i) z))
2.0ms
z
@0
(/ 1 (/ (+ (* z z) (* (* y i) (- (* y i) z))) (+ (* (* y i) (* y (* i (* y i)))) (* z (* z z)))))
2.0ms
y
@0
(- z (* y i))
1.0ms
y
@inf
(/ 1 (/ (+ (* z z) (* (* y i) (- (* y i) z))) (+ (* (* y i) (* y (* i (* y i)))) (* z (* z z)))))
1.0ms
i
@inf
(/ 1 (/ (+ (* z z) (* (* y i) (- (* y i) z))) (+ (* (* y i) (* y (* i (* y i)))) (* z (* z z)))))

rewrite448.0ms (3.4%)

Algorithm
1×batch-egg-rewrite
Rules
4708×*-lowering-*.f32
4708×*-lowering-*.f64
2270×/-lowering-/.f32
2270×/-lowering-/.f64
2224×fma-lowering-fma.f32
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
035173
1243147
22516145
09581145
Stop Event
1×iter limit
1×node limit
Counts
20 → 697
Calls
Call 1
Inputs
(+ (+ (+ a (+ t z)) (* (log c) (+ b -1/2))) (* x (log y)))
(+ (+ a (+ t z)) (* (log c) (+ b -1/2)))
(+ a (+ t z))
(+ t z)
(* y i)
(/ (* z z) (- z (* y i)))
(* z z)
(- z (* y i))
(/ 1 (/ (+ (* z z) (* (* y i) (- (* y i) z))) (+ (* (* y i) (* y (* i (* y i)))) (* z (* z z)))))
(/ (+ (* z z) (* (* y i) (- (* y i) z))) (+ (* (* y i) (* y (* i (* y i)))) (* z (* z z))))
(+ (* z z) (* (* y i) (- (* y i) z)))
(+ (* (log c) (+ b -1/2)) (+ a z))
(* (log c) (+ b -1/2))
(log c)
(+ b -1/2)
(* x (log y))
(+ (* (* y i) (* y (* i (* y i)))) (* z (* z z)))
(* (* y i) (- (* y i) z))
(* y (* i (* y i)))
(+ a z)
Outputs
(+.f64 a (+.f64 (+.f64 t z) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(+.f64 a (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))))
(+.f64 (+.f64 t z) (+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(+.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 (+.f64 a (+.f64 t z)) (*.f64 x (log.f64 y))))
(+.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))
(+.f64 (+.f64 a t) (+.f64 z (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (+.f64 a (+.f64 t z)))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) a) (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 a (+.f64 t z))) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(-.f64 (/.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 2 binary64)) (+.f64 a (-.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))))) (/.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (+.f64 a (-.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))))))
(fma.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 a (+.f64 t z)) (*.f64 x (log.f64 y))))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c) (+.f64 (+.f64 a (+.f64 t z)) (*.f64 x (log.f64 y))))
(fma.f64 x (log.f64 y) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))
(fma.f64 (log.f64 y) x (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))
(fma.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))
(fma.f64 (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z)))) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (+.f64 t z)))))) (*.f64 x (log.f64 y)))
(fma.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t)))) (+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(fma.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))) (/.f64 #s(literal 1 binary64) (-.f64 a (+.f64 t z))) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))
(fma.f64 (-.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (log.f64 y)))
(fma.f64 (-.f64 (*.f64 t t) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 t z)) (+.f64 a (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) (-.f64 (*.f64 x (log.f64 y)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))))) (+.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a (-.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))) (-.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)))))
(/.f64 (+.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) (-.f64 (*.f64 x (log.f64 y)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))))))
(/.f64 (+.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 2 binary64)) (*.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (*.f64 x (log.f64 y))))))
(/.f64 (-.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (+.f64 a (-.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) (-.f64 (*.f64 x (log.f64 y)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)))) (neg.f64 (+.f64 a (-.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))))))
(/.f64 (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z)))) (pow.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (-.f64 (pow.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) #s(literal 2 binary64)) (*.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))))
(/.f64 (-.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (pow.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) #s(literal 2 binary64))) (-.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(/.f64 (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 2 binary64))) (-.f64 (*.f64 x (log.f64 y)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) (*.f64 (-.f64 a (+.f64 t z)) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))))) (*.f64 (-.f64 a (+.f64 t z)) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (*.f64 (-.f64 a (+.f64 t z)) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))))) (*.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) (*.f64 (-.f64 (+.f64 t z) a) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))))) (*.f64 (-.f64 (+.f64 t z) a) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (*.f64 (-.f64 (+.f64 t z) a) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))))) (*.f64 (-.f64 (+.f64 t z) a) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))) (*.f64 (-.f64 (+.f64 a t) z) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))))) (*.f64 (-.f64 (+.f64 a t) z) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))) (*.f64 (-.f64 (+.f64 a t) z) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))))) (*.f64 (-.f64 (+.f64 a t) z) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (-.f64 a (+.f64 t z))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (-.f64 a (+.f64 t z))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (neg.f64 (-.f64 a (+.f64 t z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (neg.f64 (-.f64 a (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (-.f64 (+.f64 t z) a)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (-.f64 (+.f64 t z) a)))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (-.f64 (+.f64 a t) z)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))))) (-.f64 (+.f64 a t) z)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (-.f64 a (+.f64 t z))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (-.f64 a (+.f64 t z))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (neg.f64 (-.f64 a (+.f64 t z)))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (neg.f64 (-.f64 a (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (-.f64 (+.f64 t z) a)) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (-.f64 (+.f64 t z) a)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (-.f64 (+.f64 a t) z)) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (log.f64 y))) (-.f64 (+.f64 a t) z)))
(pow.f64 (/.f64 (+.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) (-.f64 (*.f64 x (log.f64 y)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))))) (+.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 a (-.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))) (-.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 3 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 2 binary64)) (*.f64 (*.f64 x (log.f64 y)) (-.f64 (*.f64 x (log.f64 y)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))))))
(*.f64 (-.f64 (pow.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) #s(literal 2 binary64)) (pow.f64 (*.f64 x (log.f64 y)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 a (-.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 (+.f64 t z) (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (+.f64 t z)))
(+.f64 (*.f64 (log.f64 c) b) (+.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (+.f64 a (+.f64 t z))))
(+.f64 (+.f64 a t) (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (+.f64 t z))
(+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) a)
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) b)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a t)) z)
(-.f64 (/.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (-.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (/.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))
(fma.f64 (log.f64 c) b (+.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (+.f64 a (+.f64 t z))))
(fma.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)) (+.f64 a (+.f64 t z)))
(fma.f64 b (log.f64 c) (+.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (+.f64 a (+.f64 t z))))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c) (+.f64 a (+.f64 t z)))
(fma.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(fma.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t)))) (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(fma.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))) (/.f64 #s(literal 1 binary64) (-.f64 a (+.f64 t z))) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(fma.f64 (-.f64 (*.f64 t t) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 t z)) (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (+.f64 t z))))) (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z)))) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (-.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z)))) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z)))) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (*.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64))) (-.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z)))) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (+.f64 t z)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) #s(literal 2 binary64)) (*.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (*.f64 a a) (pow.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) #s(literal 2 binary64))) (-.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z)))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (+.f64 t z))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))) (*.f64 (/.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (/.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) (*.f64 (/.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t)))) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (/.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t)))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))) (*.f64 (/.f64 (-.f64 t z) (-.f64 (*.f64 t t) (*.f64 z z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (/.f64 (-.f64 t z) (-.f64 (*.f64 t t) (*.f64 z z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) (*.f64 (/.f64 (-.f64 t z) (-.f64 (*.f64 t t) (*.f64 z z))) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (/.f64 (-.f64 t z) (-.f64 (*.f64 t t) (*.f64 z z))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))) (*.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) (*.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 t t) (*.f64 t z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 t t) (*.f64 t z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 t t) (*.f64 t z))) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 t t) (*.f64 t z))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 t t) (*.f64 z z)) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))) (*.f64 (-.f64 t z) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 t z) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 t t) (*.f64 z z)) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) (*.f64 (-.f64 t z) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (-.f64 t z) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))) (*.f64 (neg.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (neg.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t)))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) (*.f64 (neg.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t)))) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (neg.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t)))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 t t) (*.f64 z z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))) (*.f64 (neg.f64 (-.f64 t z)) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (neg.f64 (-.f64 t z)) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 t t) (*.f64 z z))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) (*.f64 (neg.f64 (-.f64 t z)) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (neg.f64 (-.f64 t z)) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 t t)) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))) (*.f64 (-.f64 z t) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 z t) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 t t)) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) (*.f64 (-.f64 z t) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)))) (*.f64 (-.f64 z t) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (-.f64 a (+.f64 t z)) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (-.f64 a (+.f64 t z)) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (-.f64 a (+.f64 t z)) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (-.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 a (+.f64 t z)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (-.f64 a (+.f64 t z)) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (-.f64 a (+.f64 t z)) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (-.f64 a (+.f64 t z)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 a (+.f64 t z)) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (-.f64 a (+.f64 t z)) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (-.f64 a (+.f64 t z))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (-.f64 (+.f64 t z) a) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (-.f64 (+.f64 t z) a) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (-.f64 (+.f64 t z) a) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (-.f64 (+.f64 t z) a) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (-.f64 (+.f64 t z) a) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 (+.f64 t z) a) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 (+.f64 t z) a) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (-.f64 (+.f64 t z) a) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (-.f64 (+.f64 t z) a) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (-.f64 (+.f64 t z) a) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 (+.f64 t z) a) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (-.f64 (+.f64 t z) a) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (-.f64 (+.f64 a t) z) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (-.f64 (+.f64 a t) z) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (-.f64 (+.f64 a t) z) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (-.f64 (+.f64 a t) z) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (-.f64 (+.f64 a t) z) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 (+.f64 a t) z) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 (+.f64 a t) z) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (-.f64 (+.f64 a t) z) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (-.f64 (+.f64 a t) z) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (-.f64 (+.f64 a t) z) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 (+.f64 a t) z) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (-.f64 (+.f64 a t) z) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (-.f64 a (+.f64 t z))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 a (+.f64 t z))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (neg.f64 (-.f64 a (+.f64 t z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (neg.f64 (-.f64 a (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (-.f64 (+.f64 t z) a)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 (+.f64 t z) a)))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (-.f64 (+.f64 a t) z)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 (+.f64 a t) z)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (-.f64 a (+.f64 t z))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 a (+.f64 t z))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (neg.f64 (-.f64 a (+.f64 t z)))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 (-.f64 a (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (-.f64 (+.f64 t z) a)) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 (+.f64 t z) a)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (-.f64 (+.f64 a t) z)) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 (+.f64 a t) z)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 a (+.f64 t z))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 a (+.f64 t z))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (-.f64 a (+.f64 t z)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (-.f64 a (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 (+.f64 t z) a)) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (+.f64 t z) a)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 (+.f64 a t) z)) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (+.f64 a t) z)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (-.f64 a (+.f64 t z))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 a (+.f64 t z))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (neg.f64 (-.f64 a (+.f64 t z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 a (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (-.f64 (+.f64 t z) a)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (+.f64 t z) a)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (-.f64 (+.f64 a t) z)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (+.f64 a t) z)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 a (+.f64 t z))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 a (+.f64 t z))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (neg.f64 (-.f64 a (+.f64 t z)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (-.f64 a (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 (+.f64 t z) a)) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (+.f64 t z) a)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 (+.f64 a t) z)) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (+.f64 a t) z)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (-.f64 a (+.f64 t z))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 a (+.f64 t z))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (neg.f64 (-.f64 a (+.f64 t z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 a (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (-.f64 (+.f64 t z) a)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (+.f64 t z) a)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (-.f64 (+.f64 a t) z)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (+.f64 a t) z)))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (/.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (/.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (/.f64 (-.f64 t z) (-.f64 (*.f64 t t) (*.f64 z z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (/.f64 (-.f64 t z) (-.f64 (*.f64 t t) (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 z z) (-.f64 (*.f64 t t) (*.f64 t z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (+.f64 (*.f64 z z) (-.f64 (*.f64 t t) (*.f64 t z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (-.f64 t z)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (-.f64 (*.f64 t t) (*.f64 z z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (-.f64 t z)))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (neg.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (neg.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (neg.f64 (-.f64 t z))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (neg.f64 (-.f64 (*.f64 t t) (*.f64 z z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (neg.f64 (-.f64 t z))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (-.f64 z t)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (-.f64 (*.f64 z z) (*.f64 t t)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a))) (-.f64 z t)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (/.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 (-.f64 t z) (-.f64 (*.f64 t t) (*.f64 z z)))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (/.f64 (-.f64 t z) (-.f64 (*.f64 t t) (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)) (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t)))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)) (+.f64 (*.f64 z z) (-.f64 (*.f64 t t) (*.f64 t z)))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (+.f64 (*.f64 z z) (-.f64 (*.f64 t t) (*.f64 t z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)) (-.f64 t z)) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (-.f64 (*.f64 t t) (*.f64 z z)))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (-.f64 t z)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)) (neg.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t)))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (neg.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)) (neg.f64 (-.f64 t z))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (neg.f64 (-.f64 (*.f64 t t) (*.f64 z z))))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (neg.f64 (-.f64 t z))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 a a)) (-.f64 z t)) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (-.f64 (*.f64 z z) (*.f64 t t)))) (*.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (-.f64 z t)))
(pow.f64 (/.f64 (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (+.f64 t z))))) (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z)))) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (-.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z)))) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (*.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a (+.f64 t z)))))))
(*.f64 (-.f64 (*.f64 (+.f64 a (+.f64 t z)) (+.f64 a (+.f64 t z))) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))
(+.f64 a (+.f64 t z))
(+.f64 t (+.f64 a z))
(+.f64 z (+.f64 a t))
(+.f64 (+.f64 t z) a)
(+.f64 (+.f64 a z) t)
(+.f64 (+.f64 a t) z)
(-.f64 (/.f64 (*.f64 a a) (-.f64 a (+.f64 t z))) (/.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 a (+.f64 t z))))
(fma.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) t)
(fma.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t)))) a)
(fma.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 a z)) t)
(fma.f64 (-.f64 (*.f64 t t) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 t z)) a)
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (+.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 a (+.f64 t z)))))
(/.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))) (-.f64 a (+.f64 t z)))
(/.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))))
(/.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) (neg.f64 (-.f64 a (+.f64 t z))))
(/.f64 (+.f64 (*.f64 (+.f64 a t) (*.f64 (+.f64 a t) (+.f64 a t))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a t) z))))
(/.f64 (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 a a)) (-.f64 (+.f64 t z) a))
(/.f64 (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 z z)) (-.f64 (+.f64 a t) z))
(pow.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 a (+.f64 t z)) (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z)))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 t z) (*.f64 (+.f64 t z) (+.f64 t z)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (*.f64 (+.f64 t z) (-.f64 (+.f64 t z) a)))))
(*.f64 (-.f64 (*.f64 a a) (*.f64 (+.f64 t z) (+.f64 t z))) (/.f64 #s(literal 1 binary64) (-.f64 a (+.f64 t z))))
(+.f64 t z)
(+.f64 z t)
(-.f64 (/.f64 (*.f64 t t) (-.f64 t z)) (/.f64 (*.f64 z z) (-.f64 t z)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t z) (-.f64 (*.f64 t t) (*.f64 z z))))
(/.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))) (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))))
(/.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))) (+.f64 (*.f64 z z) (-.f64 (*.f64 t t) (*.f64 t z))))
(/.f64 (-.f64 (*.f64 t t) (*.f64 z z)) (-.f64 t z))
(/.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t)))) (neg.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t)))))
(/.f64 (neg.f64 (-.f64 (*.f64 t t) (*.f64 z z))) (neg.f64 (-.f64 t z)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 t t)) (-.f64 z t))
(pow.f64 (/.f64 (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 t z) (-.f64 (*.f64 t t) (*.f64 z z))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 t (*.f64 t t))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 t t) (*.f64 z (-.f64 z t)))))
(*.f64 (-.f64 (*.f64 t t) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 t z)))
(*.f64 y i)
(*.f64 i y)
(exp.f64 (*.f64 (log.f64 (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z))) #s(literal -1 binary64)))
(neg.f64 (/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i)))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 z z)) (-.f64 z (*.f64 y i))))
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 z z)) (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 z z))) (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i)))))
(/.f64 (*.f64 (*.f64 z z) #s(literal 1 binary64)) (-.f64 z (*.f64 y i)))
(pow.f64 (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 z (/.f64 z (-.f64 z (*.f64 y i))))
(*.f64 (*.f64 z z) (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))))
(*.f64 #s(literal 1 binary64) (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 z (*.f64 y i)))))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (*.f64 z z))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 z (*.f64 y i))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 z z)) #s(literal -1 binary64)))
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
(*.f64 (/.f64 (*.f64 z z) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(*.f64 (/.f64 (*.f64 z z) (-.f64 (*.f64 z z) (*.f64 (*.f64 y i) (*.f64 y i)))) (+.f64 z (*.f64 y i)))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 z)))
(pow.f64 z #s(literal 2 binary64))
(pow.f64 (*.f64 z z) #s(literal 1 binary64))
(pow.f64 (-.f64 #s(literal 0 binary64) z) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 z)) #s(literal 2 binary64))
(*.f64 z z)
(*.f64 (-.f64 #s(literal 0 binary64) z) (-.f64 #s(literal 0 binary64) z))
(*.f64 (exp.f64 (log.f64 z)) (exp.f64 (log.f64 z)))
(+.f64 z (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(+.f64 (-.f64 #s(literal 0 binary64) (*.f64 y i)) z)
(-.f64 z (*.f64 y i))
(-.f64 (/.f64 (*.f64 z (*.f64 z z)) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i))))) (/.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i))))))
(-.f64 (/.f64 (*.f64 z z) (+.f64 z (*.f64 y i))) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 z (*.f64 y i))))
(fma.f64 y (neg.f64 i) z)
(fma.f64 i (-.f64 #s(literal 0 binary64) y) z)
(fma.f64 #s(literal -1 binary64) (*.f64 y i) z)
(fma.f64 (-.f64 #s(literal 0 binary64) y) i z)
(fma.f64 (neg.f64 i) y z)
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 (*.f64 y i) (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (+.f64 (*.f64 z z) (-.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z (-.f64 #s(literal 0 binary64) (*.f64 y i))))))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 y i) (*.f64 y i))) (+.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 y i) (*.f64 y i))) (-.f64 z (-.f64 #s(literal 0 binary64) (*.f64 y i))))
(/.f64 (neg.f64 (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (neg.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i))))))
(/.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 y i) (*.f64 y i)))) (neg.f64 (+.f64 z (*.f64 y i))))
(pow.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 (*.f64 y i) (*.f64 y i)))) #s(literal -1 binary64))
(*.f64 (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i))))))
(*.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (*.f64 z (*.f64 z z))))
(+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (*.f64 z (*.f64 z z))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))))
(+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))) (*.f64 (*.f64 z (*.f64 z z)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))))
(+.f64 (*.f64 (*.f64 z (*.f64 z z)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))) #s(literal -1 binary64)))
(fma.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (*.f64 (*.f64 z (*.f64 z z)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))))
(fma.f64 (*.f64 z (*.f64 z z)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))))
(fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (*.f64 z (*.f64 z z))))
(fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (*.f64 z (*.f64 z z)) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))
(/.f64 #s(literal -1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))
(/.f64 (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (*.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z (*.f64 z z)) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (*.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z))))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z (*.f64 z z)) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))))))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))))) (*.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (*.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z))))))) (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z (*.f64 z z)) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))))))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (-.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))))) (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))
(/.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))
(pow.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) #s(literal 1 binary64))
(pow.f64 (pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))) (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))) #s(literal -1/2 binary64))
(pow.f64 (exp.f64 (log.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))))
(*.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))) #s(literal 1 binary64)) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))
(*.f64 (pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) #s(literal 1/2 binary64)) (pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))) #s(literal -1 binary64)))
(*.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))))) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (-.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 z z)))))
(*.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))) (-.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))
(*.f64 (pow.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (*.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z (*.f64 z z)) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))))))
(*.f64 (pow.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (-.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (*.f64 (log.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))) #s(literal -1 binary64)) #s(literal -1 binary64)))
(exp.f64 (neg.f64 (*.f64 (log.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))) #s(literal -1 binary64))))
(neg.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) #s(literal 1 binary64)))
(/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))
(/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))))
(/.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))) #s(literal -1 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))))
(/.f64 (+.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))) (*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (-.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 z z))))))
(/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))) (*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (-.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))
(/.f64 (*.f64 (+.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))) #s(literal 1 binary64)) (*.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (-.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 z z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))) #s(literal 1 binary64)) (*.f64 (-.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))))
(/.f64 (*.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) #s(literal 1 binary64)) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))
(/.f64 (*.f64 (+.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (-.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 z z)))))
(/.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))) (-.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))
(pow.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))) #s(literal 1 binary64))
(pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(*.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(*.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))) #s(literal 1 binary64)))
(*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (pow.f64 (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))) #s(literal -1 binary64)))
(*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) #s(literal -1 binary64)))
(*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (*.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z))))))) (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z (*.f64 z z)) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))))))
(*.f64 (/.f64 (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (-.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))))) (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) #s(literal 1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) #s(literal 1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))))
(*.f64 (pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (-.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 z z))))))
(*.f64 (pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))
(+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))
(+.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 z z))
(-.f64 (/.f64 (*.f64 z (*.f64 z (*.f64 z z))) (-.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (-.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))
(fma.f64 z z (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))
(fma.f64 y (*.f64 i (-.f64 (*.f64 y i) z)) (*.f64 z z))
(fma.f64 i (*.f64 y (-.f64 (*.f64 y i) z)) (*.f64 z z))
(fma.f64 (*.f64 y i) (-.f64 (*.f64 y i) z) (*.f64 z z))
(fma.f64 (-.f64 (*.f64 y i) z) (*.f64 y i) (*.f64 z z))
(fma.f64 (*.f64 i (-.f64 (*.f64 y i) z)) y (*.f64 z z))
(fma.f64 (*.f64 (-.f64 (*.f64 y i) z) y) i (*.f64 z z))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (-.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 z z)))) (+.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))))
(/.f64 (+.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (-.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))) (+.f64 (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))))
(/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))) (-.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))
(/.f64 (neg.f64 (+.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))))) (neg.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (-.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 z z))))))
(/.f64 (neg.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))) (neg.f64 (-.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))
(/.f64 (-.f64 (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (*.f64 z (*.f64 z (*.f64 z z)))) (-.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 z z)))
(pow.f64 (/.f64 (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (-.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 z z)))) (+.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))) (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (-.f64 (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))) (*.f64 z z))))))
(*.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y i) (*.f64 (-.f64 (*.f64 y i) z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 z (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+.f64 (+.f64 a z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+.f64 (*.f64 (log.f64 c) b) (+.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (+.f64 a z)))
(+.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) z)
(+.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) z) a)
(+.f64 (+.f64 (+.f64 a z) (*.f64 (log.f64 c) b)) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))) (/.f64 (*.f64 (+.f64 a z) (+.f64 a z)) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))))
(fma.f64 (log.f64 c) b (+.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (+.f64 a z)))
(fma.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)) (+.f64 a z))
(fma.f64 b (log.f64 c) (+.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (+.f64 a z)))
(fma.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c) (+.f64 a z))
(fma.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(fma.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 a z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 (+.f64 a z) (-.f64 (+.f64 a z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 (+.f64 a z) (*.f64 (+.f64 a z) (+.f64 a z))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z)) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 (+.f64 a z) (+.f64 a z)))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 (+.f64 a z) (*.f64 (+.f64 a z) (+.f64 a z)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 (+.f64 a z) (-.f64 (+.f64 a z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 (+.f64 a z) (*.f64 (+.f64 a z) (+.f64 a z)))) (+.f64 (*.f64 (+.f64 a z) (+.f64 a z)) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 c) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (+.f64 a z))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 (+.f64 a z) (+.f64 a z))) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z)))
(/.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 (+.f64 a z) (*.f64 (+.f64 a z) (+.f64 a z))))) (neg.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 (+.f64 a z) (-.f64 (+.f64 a z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 (+.f64 a z) (+.f64 a z)))) (neg.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))))
(/.f64 (+.f64 (pow.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) #s(literal 3 binary64)) (*.f64 z (*.f64 z z))) (+.f64 (pow.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) #s(literal 2 binary64)) (-.f64 (*.f64 z z) (*.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) z))))
(/.f64 (-.f64 (*.f64 (+.f64 a z) (+.f64 a z)) (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64))) (-.f64 (+.f64 a z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (pow.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) #s(literal 2 binary64)) (*.f64 z z)) (-.f64 (+.f64 a (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) z))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z)))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (-.f64 a z)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (neg.f64 (-.f64 a z))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (neg.f64 (-.f64 (*.f64 a a) (*.f64 z z))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (neg.f64 (-.f64 a z))))
(/.f64 (+.f64 (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (-.f64 z a)) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z)))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z)))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (-.f64 a z)) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (neg.f64 (-.f64 a z))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 (-.f64 (*.f64 a a) (*.f64 z z))))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (neg.f64 (-.f64 a z))))
(/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (-.f64 z a)) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 a z)) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (-.f64 a z))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (-.f64 (*.f64 a a) (*.f64 z z))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (-.f64 a z))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (-.f64 z a)) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (-.f64 a z)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (neg.f64 (-.f64 a z))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 (*.f64 a a) (*.f64 z z))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 a z))))
(/.f64 (+.f64 (*.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (-.f64 z a)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 a z)) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (neg.f64 (-.f64 a z))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (-.f64 (*.f64 a a) (*.f64 z z))))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (neg.f64 (-.f64 a z))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (-.f64 z a)) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z)))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (-.f64 a z)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 a a) (*.f64 z z)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 a z)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (neg.f64 (-.f64 a z))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 (*.f64 a a) (*.f64 z z))))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (neg.f64 (-.f64 a z))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (-.f64 z a)) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 z z) (*.f64 a a)))) (*.f64 (+.f64 b #s(literal 1/2 binary64)) (-.f64 z a)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z))) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (-.f64 a z) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (-.f64 a z) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (-.f64 a z) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (-.f64 a z) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (-.f64 a z) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 a z) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 a z) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (-.f64 a z) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (-.f64 a z) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (-.f64 a z) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 a z) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (-.f64 a z) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 z z))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (neg.f64 (-.f64 a z)) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (-.f64 a z)) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 z z))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (neg.f64 (-.f64 a z)) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (-.f64 a z)) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 z z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (neg.f64 (-.f64 a z)) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (-.f64 a z)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 z z))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (-.f64 a z)) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (neg.f64 (-.f64 a z)) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 z z))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (neg.f64 (-.f64 a z)) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (-.f64 a z)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 z z))) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (neg.f64 (-.f64 a z)) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (neg.f64 (-.f64 a z)) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))) (*.f64 (-.f64 z a) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))))) (*.f64 (-.f64 z a) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) (*.f64 (-.f64 z a) (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))))) (*.f64 (-.f64 z a) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (-.f64 z a) (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 z a) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 z a) (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))) (*.f64 (-.f64 z a) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (-.f64 z a) (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (-.f64 z a) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (+.f64 b #s(literal 1/2 binary64))) (*.f64 (-.f64 z a) (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (-.f64 z a) (+.f64 b #s(literal 1/2 binary64))))
(pow.f64 (/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 (+.f64 a z) (-.f64 (+.f64 a z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 (+.f64 a z) (*.f64 (+.f64 a z) (+.f64 a z))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z)) (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 (+.f64 a z) (+.f64 a z)))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 3 binary64)) (*.f64 (+.f64 a z) (*.f64 (+.f64 a z) (+.f64 a z)))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 (+.f64 a z) (-.f64 (+.f64 a z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))))
(*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) #s(literal 2 binary64)) (*.f64 (+.f64 a z) (+.f64 a z))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))))
(+.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(+.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 (log.f64 c) b))
(fma.f64 (log.f64 c) b (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(fma.f64 (log.f64 c) #s(literal -1/2 binary64) (*.f64 (log.f64 c) b))
(fma.f64 b (log.f64 c) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 c) b))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 2 binary64))) (-.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64))))
(/.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (*.f64 (log.f64 c) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (+.f64 b #s(literal 1/2 binary64)))
(/.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 b #s(literal 1/2 binary64)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c))
(log.f64 c)
(+.f64 b #s(literal -1/2 binary64))
(+.f64 #s(literal -1/2 binary64) b)
(-.f64 (/.f64 (*.f64 b b) (+.f64 b #s(literal 1/2 binary64))) (/.f64 #s(literal 1/4 binary64) (+.f64 b #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))))
(/.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (+.f64 #s(literal 1/4 binary64) (-.f64 (*.f64 b b) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (+.f64 b #s(literal 1/2 binary64)))
(/.f64 (neg.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (neg.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) (neg.f64 (+.f64 b #s(literal 1/2 binary64))))
(/.f64 (-.f64 #s(literal 1/4 binary64) (*.f64 b b)) (-.f64 #s(literal -1/2 binary64) b))
(pow.f64 (/.f64 (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64)))) (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 b #s(literal 1/2 binary64)) (+.f64 (*.f64 b b) #s(literal -1/4 binary64))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (-.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal -1/2 binary64))))))
(*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 b #s(literal 1/2 binary64))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 y) x)
(+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))
(+.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))
(-.f64 (/.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))) (/.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(fma.f64 z (*.f64 z z) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))
(fma.f64 y (*.f64 (*.f64 y i) (*.f64 y (*.f64 i i))) (*.f64 z (*.f64 z z)))
(fma.f64 i (*.f64 y (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))
(fma.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z (*.f64 z z)))
(fma.f64 (*.f64 z z) z (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))
(fma.f64 (*.f64 y (*.f64 i i)) (*.f64 y (*.f64 y i)) (*.f64 z (*.f64 z z)))
(fma.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 y i) (*.f64 z (*.f64 z z)))
(fma.f64 (*.f64 y (*.f64 y i)) (*.f64 y (*.f64 i i)) (*.f64 z (*.f64 z z)))
(fma.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i i))) y (*.f64 z (*.f64 z z)))
(fma.f64 (*.f64 y (*.f64 y y)) (*.f64 i (*.f64 i i)) (*.f64 z (*.f64 z z)))
(fma.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y)) (*.f64 z (*.f64 z z)))
(fma.f64 (pow.f64 z #s(literal 3/2 binary64)) (pow.f64 z #s(literal 3/2 binary64)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))
(fma.f64 (pow.f64 (*.f64 y i) #s(literal 3/2 binary64)) (pow.f64 (*.f64 y i) #s(literal 3/2 binary64)) (*.f64 z (*.f64 z z)))
(fma.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 y i)) y) i (*.f64 z (*.f64 z z)))
(fma.f64 (*.f64 (*.f64 y (*.f64 y i)) (*.f64 y i)) i (*.f64 z (*.f64 z z)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z (*.f64 z z)) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))))) (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (*.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (-.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (*.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))))) (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z (*.f64 z z)) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (*.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))))) (+.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (-.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z (*.f64 z z)))))))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z))))) (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))))
(/.f64 (neg.f64 (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (*.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z))))))) (neg.f64 (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z (*.f64 z z)) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))))) (neg.f64 (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))))
(pow.f64 (/.f64 (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z (*.f64 z z)) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))))) (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (*.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (-.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))) (*.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z (*.f64 z z)) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))))))))
(*.f64 (-.f64 (*.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i)))) (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z))))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(+.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) z)))
(+.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 y i)))
(fma.f64 y (*.f64 y (*.f64 i i)) (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 y (*.f64 y (*.f64 i i)) (*.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 y i)))
(fma.f64 i (*.f64 y (*.f64 y i)) (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 i (*.f64 y (*.f64 y i)) (*.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 y i)))
(fma.f64 (*.f64 y i) (*.f64 y i) (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 (*.f64 y i) (*.f64 y i) (*.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 y i)))
(fma.f64 (*.f64 y (*.f64 i i)) y (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 (*.f64 y (*.f64 i i)) y (*.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 y i)))
(fma.f64 (*.f64 y (*.f64 y i)) i (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 (*.f64 y (*.f64 y i)) i (*.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 y i)))
(fma.f64 (*.f64 y y) (*.f64 i i) (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 (*.f64 y y) (*.f64 i i) (*.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 y i)))
(fma.f64 (*.f64 i i) (*.f64 y y) (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 (*.f64 i i) (*.f64 y y) (*.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 y i)))
(/.f64 (*.f64 (*.f64 y i) (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z (+.f64 z (*.f64 y i)))))
(/.f64 (*.f64 (*.f64 y i) (-.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z z))) (+.f64 z (*.f64 y i)))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z))) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z (+.f64 z (*.f64 y i)))))
(/.f64 (*.f64 (-.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z z)) (*.f64 y i)) (+.f64 z (*.f64 y i)))
(*.f64 y (*.f64 i (-.f64 (*.f64 y i) z)))
(*.f64 i (*.f64 y (-.f64 (*.f64 y i) z)))
(*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))
(*.f64 (-.f64 (*.f64 y i) z) (*.f64 y i))
(*.f64 (*.f64 i (-.f64 (*.f64 y i) z)) y)
(*.f64 (*.f64 (-.f64 (*.f64 y i) z) y) i)
(exp.f64 (*.f64 (log.f64 (*.f64 y i)) #s(literal 2 binary64)))
(pow.f64 (*.f64 y i) #s(literal 2 binary64))
(pow.f64 (-.f64 #s(literal 0 binary64) (*.f64 y i)) #s(literal 2 binary64))
(*.f64 y (*.f64 y (*.f64 i i)))
(*.f64 i (*.f64 y (*.f64 y i)))
(*.f64 (*.f64 y i) (*.f64 y i))
(*.f64 (*.f64 y (*.f64 i i)) y)
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 y i)) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(*.f64 (*.f64 y (*.f64 y i)) i)
(*.f64 (*.f64 y y) (*.f64 i i))
(*.f64 (*.f64 i i) (*.f64 y y))
(+.f64 a z)
(+.f64 z a)
(-.f64 (/.f64 (*.f64 a a) (-.f64 a z)) (/.f64 (*.f64 z z) (-.f64 a z)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))))
(/.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))))
(/.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (+.f64 (*.f64 z z) (-.f64 (*.f64 a a) (*.f64 a z))))
(/.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (-.f64 a z))
(/.f64 (neg.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))))
(/.f64 (neg.f64 (-.f64 (*.f64 a a) (*.f64 z z))) (neg.f64 (-.f64 a z)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 a a)) (-.f64 z a))
(pow.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a))) (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 a z) (-.f64 (*.f64 a a) (*.f64 z z))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 z (*.f64 z z)) (*.f64 a (*.f64 a a))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (*.f64 z (-.f64 z a)))))
(*.f64 (-.f64 (*.f64 a a) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 a z)))

simplify391.0ms (3%)

Algorithm
1×egg-herbie
Rules
4130×*-lowering-*.f32
4130×*-lowering-*.f64
4088×+-lowering-+.f64
4088×+-lowering-+.f32
1402×fma-lowering-fma.f32
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
08697649
130346531
086086531
Stop Event
1×iter limit
1×node limit
Counts
660 → 660
Calls
Call 1
Inputs
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ t (+ z (* (log c) (- b 1/2))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (* (log c) (- b 1/2)))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (* (log c) (- b 1/2)))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (* (log c) (- b 1/2)))) a)) 1)))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* (log c) (- b 1/2)) t)))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* (log c) (- b 1/2)) t)))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* (log c) (- b 1/2)) t)))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) t)) 1)))
(+ a (+ t (* (log c) (- b 1/2))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* (log c) (- b 1/2)) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* (log c) (- b 1/2)) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* (log c) (- b 1/2)) z)))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (* (log c) (- b 1/2)))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (* (log c) (- b 1/2)))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (* (log c) (- b 1/2)))) z)) 1)))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (* -1 (* (log (/ 1 c)) (- b 1/2))))))
(+ a (+ t (+ z (* -1 (* (log (/ 1 c)) (- b 1/2))))))
(+ a (+ t (+ z (* -1 (* (log (/ 1 c)) (- b 1/2))))))
(+ a (+ t (+ z (* -1 (* (log (/ 1 c)) (- b 1/2))))))
(+ a (+ t (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+ a (+ t (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+ a (+ t (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+ a (+ t (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+ a (+ t (+ z (* -1/2 (log c)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* b (log c))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* b (log c))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* b (log c))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (/ z b))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (/ z b))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (/ z b))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (* -1/2 (log c))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (* -1/2 (log c))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (* -1/2 (log c))))) b)))))
(+ t z)
(+ a (+ t z))
(+ a (+ t z))
(+ a (+ t z))
a
(* a (+ 1 (+ (/ t a) (/ z a))))
(* a (+ 1 (+ (/ t a) (/ z a))))
(* a (+ 1 (+ (/ t a) (/ z a))))
a
(* -1 (* a (- (* -1 (/ (+ t z) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t z) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t z) a)) 1)))
(+ a z)
(+ a (+ t z))
(+ a (+ t z))
(+ a (+ t z))
t
(* t (+ 1 (+ (/ a t) (/ z t))))
(* t (+ 1 (+ (/ a t) (/ z t))))
(* t (+ 1 (+ (/ a t) (/ z t))))
t
(* -1 (* t (- (* -1 (/ (+ a z) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a z) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a z) t)) 1)))
(+ a t)
(+ a (+ t z))
(+ a (+ t z))
(+ a (+ t z))
z
(* z (+ 1 (+ (/ a z) (/ t z))))
(* z (+ 1 (+ (/ a z) (/ t z))))
(* z (+ 1 (+ (/ a z) (/ t z))))
z
(* -1 (* z (- (* -1 (/ (+ a t) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a t) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a t) z)) 1)))
z
(+ t z)
(+ t z)
(+ t z)
t
(* t (+ 1 (/ z t)))
(* t (+ 1 (/ z t)))
(* t (+ 1 (/ z t)))
t
(* -1 (* t (- (* -1 (/ z t)) 1)))
(* -1 (* t (- (* -1 (/ z t)) 1)))
(* -1 (* t (- (* -1 (/ z t)) 1)))
t
(+ t z)
(+ t z)
(+ t z)
z
(* z (+ 1 (/ t z)))
(* z (+ 1 (/ t z)))
(* z (+ 1 (/ t z)))
z
(* -1 (* z (- (* -1 (/ t z)) 1)))
(* -1 (* z (- (* -1 (/ t z)) 1)))
(* -1 (* z (- (* -1 (/ t z)) 1)))
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* -1 (/ (pow z 2) (* i y)))
(* (pow z 2) (- (* -1 (/ z (* (pow i 2) (pow y 2)))) (/ 1 (* i y))))
(* (pow z 2) (- (* z (- (* -1 (/ z (* (pow i 3) (pow y 3)))) (/ 1 (* (pow i 2) (pow y 2))))) (/ 1 (* i y))))
(* (pow z 2) (- (* z (- (* z (- (* -1 (/ z (* (pow i 4) (pow y 4)))) (/ 1 (* (pow i 3) (pow y 3))))) (/ 1 (* (pow i 2) (pow y 2))))) (/ 1 (* i y))))
z
(* z (+ 1 (/ (* i y) z)))
(* z (- (+ 1 (/ (* (pow i 2) (pow y 2)) (pow z 2))) (* -1 (/ (* i y) z))))
(* z (- (+ 1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) (+ (* -1 (/ (* i y) z)) (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2))))))
z
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(* -1 (* z (- (* -1 (/ (- (/ (* (pow i 2) (pow y 2)) z) (* -1 (* i y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (- (* -1 (/ (- (* -1 (/ (* (pow i 3) (pow y 3)) z)) (* (pow i 2) (pow y 2))) z)) (* -1 (* i y))) z)) 1)))
z
(+ z (* i y))
(+ z (* y (- (/ (* (pow i 2) y) z) (* -1 i))))
(+ z (* y (- (* y (- (/ (* (pow i 3) y) (pow z 2)) (* -1 (/ (pow i 2) z)))) (* -1 i))))
(* -1 (/ (pow z 2) (* i y)))
(/ (+ (* -1 (/ (pow z 2) i)) (* -1 (/ (pow z 3) (* (pow i 2) y)))) y)
(/ (- (+ (* -1 (/ (pow z 2) i)) (* -1 (/ (pow z 4) (* (pow i 3) (pow y 2))))) (/ (pow z 3) (* (pow i 2) y))) y)
(/ (- (+ (* -1 (/ (pow z 2) i)) (* -1 (/ (pow z 5) (* (pow i 4) (pow y 3))))) (+ (/ (pow z 3) (* (pow i 2) y)) (/ (pow z 4) (* (pow i 3) (pow y 2))))) y)
(* -1 (/ (pow z 2) (* i y)))
(* -1 (/ (+ (/ (pow z 2) i) (/ (pow z 3) (* (pow i 2) y))) y))
(* -1 (/ (+ (* -1 (/ (- (* -1 (/ (pow z 4) (* (pow i 3) y))) (/ (pow z 3) (pow i 2))) y)) (/ (pow z 2) i)) y))
(* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (pow z 5) (* (pow i 4) y)) (* -1 (/ (pow z 4) (pow i 3)))) y)) (/ (pow z 3) (pow i 2))) y)) (/ (pow z 2) i)) y))
z
(+ z (* i y))
(+ z (* i (- (/ (* i (pow y 2)) z) (* -1 y))))
(+ z (* i (- (* i (- (/ (* i (pow y 3)) (pow z 2)) (* -1 (/ (pow y 2) z)))) (* -1 y))))
(* -1 (/ (pow z 2) (* i y)))
(/ (+ (* -1 (/ (pow z 2) y)) (* -1 (/ (pow z 3) (* i (pow y 2))))) i)
(/ (- (+ (* -1 (/ (pow z 2) y)) (* -1 (/ (pow z 4) (* (pow i 2) (pow y 3))))) (/ (pow z 3) (* i (pow y 2)))) i)
(/ (- (+ (* -1 (/ (pow z 2) y)) (* -1 (/ (pow z 5) (* (pow i 3) (pow y 4))))) (+ (/ (pow z 3) (* i (pow y 2))) (/ (pow z 4) (* (pow i 2) (pow y 3))))) i)
(* -1 (/ (pow z 2) (* i y)))
(* -1 (/ (+ (/ (pow z 2) y) (/ (pow z 3) (* i (pow y 2)))) i))
(* -1 (/ (+ (* -1 (/ (- (* -1 (/ (pow z 4) (* i (pow y 3)))) (/ (pow z 3) (pow y 2))) i)) (/ (pow z 2) y)) i))
(* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (pow z 5) (* i (pow y 4))) (* -1 (/ (pow z 4) (pow y 3)))) i)) (/ (pow z 3) (pow y 2))) i)) (/ (pow z 2) y)) i))
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(pow z 2)
(* -1 (* i y))
(- z (* i y))
(- z (* i y))
(- z (* i y))
z
(* z (+ 1 (* -1 (/ (* i y) z))))
(* z (+ 1 (* -1 (/ (* i y) z))))
(* z (+ 1 (* -1 (/ (* i y) z))))
z
(* -1 (* z (- (/ (* i y) z) 1)))
(* -1 (* z (- (/ (* i y) z) 1)))
(* -1 (* z (- (/ (* i y) z) 1)))
z
(+ z (* -1 (* i y)))
(+ z (* -1 (* i y)))
(+ z (* -1 (* i y)))
(* -1 (* i y))
(* y (- (/ z y) i))
(* y (- (/ z y) i))
(* y (- (/ z y) i))
(* -1 (* i y))
(* -1 (* y (- (* -1 (/ z y)) (* -1 i))))
(* -1 (* y (- (* -1 (/ z y)) (* -1 i))))
(* -1 (* y (- (* -1 (/ z y)) (* -1 i))))
z
(+ z (* -1 (* i y)))
(+ z (* -1 (* i y)))
(+ z (* -1 (* i y)))
(* -1 (* i y))
(* i (- (/ z i) y))
(* i (- (/ z i) y))
(* i (- (/ z i) y))
(* -1 (* i y))
(* -1 (* i (- (* -1 (/ z i)) (* -1 y))))
(* -1 (* i (- (* -1 (/ z i)) (* -1 y))))
(* -1 (* i (- (* -1 (/ z i)) (* -1 y))))
(* i y)
(+ z (* i y))
(+ z (* i y))
(+ z (* i y))
z
(* z (+ 1 (/ (* i y) z)))
(* z (- (+ 1 (* -1 (/ (+ (* -1 (* (pow i 2) (pow y 2))) (* (pow i 2) (pow y 2))) (pow z 2)))) (* -1 (/ (* i y) z))))
(* z (- (+ 1 (* -1 (/ (* i (* y (+ (* -1 (* (pow i 2) (pow y 2))) (* (pow i 2) (pow y 2))))) (pow z 3)))) (+ (* -1 (/ (* i y) z)) (+ (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2))) (/ (* (pow i 2) (pow y 2)) (pow z 2))))))
z
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(* -1 (* z (- (* -1 (/ (- (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (/ (* (pow i 2) (pow y 2)) z)) (* -1 (* i y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (- (* -1 (/ (- (* -1 (/ (* i (* y (+ (* -1 (* (pow i 2) (pow y 2))) (* (pow i 2) (pow y 2))))) z)) (+ (* -1 (* (pow i 2) (pow y 2))) (* (pow i 2) (pow y 2)))) z)) (* -1 (* i y))) z)) 1)))
z
(+ z (* i y))
(+ z (* y (- (* -1 (* y (+ (* -1 (/ (pow i 2) z)) (/ (pow i 2) z)))) (* -1 i))))
(+ z (* y (- (* y (- (* -1 (/ (* i (* y (+ (* -1 (/ (pow i 2) z)) (/ (pow i 2) z)))) z)) (+ (* -1 (/ (pow i 2) z)) (/ (pow i 2) z)))) (* -1 i))))
(* i y)
(* y (+ i (/ z y)))
(* y (- (+ i (* -1 (/ (+ (* -1 (/ (pow z 2) i)) (/ (pow z 2) i)) (pow y 2)))) (* -1 (/ z y))))
(* y (- (+ i (* -1 (/ (* z (+ (* -1 (/ (pow z 2) i)) (/ (pow z 2) i))) (* i (pow y 3))))) (+ (* -1 (/ z y)) (+ (* -1 (/ (pow z 2) (* i (pow y 2)))) (/ (pow z 2) (* i (pow y 2)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (- (+ (* -1 (/ (pow z 2) (* i y))) (/ (pow z 2) (* i y))) (* -1 z)) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (- (* -1 (/ (- (* -1 (/ (* z (+ (* -1 (/ (pow z 2) i)) (/ (pow z 2) i))) (* i y))) (+ (* -1 (/ (pow z 2) i)) (/ (pow z 2) i))) y)) (* -1 z)) y)))))
z
(+ z (* i y))
(+ z (* i (- (* -1 (* i (+ (* -1 (/ (pow y 2) z)) (/ (pow y 2) z)))) (* -1 y))))
(+ z (* i (- (* i (- (* -1 (/ (* i (* y (+ (* -1 (/ (pow y 2) z)) (/ (pow y 2) z)))) z)) (+ (* -1 (/ (pow y 2) z)) (/ (pow y 2) z)))) (* -1 y))))
(* i y)
(* i (+ y (/ z i)))
(* i (- (+ y (* -1 (/ (+ (* -1 (/ (pow z 2) y)) (/ (pow z 2) y)) (pow i 2)))) (* -1 (/ z i))))
(* i (- (+ y (* -1 (/ (* z (+ (* -1 (/ (pow z 2) y)) (/ (pow z 2) y))) (* (pow i 3) y)))) (+ (* -1 (/ z i)) (+ (* -1 (/ (pow z 2) (* (pow i 2) y))) (/ (pow z 2) (* (pow i 2) y))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (- (+ (* -1 (/ (pow z 2) (* i y))) (/ (pow z 2) (* i y))) (* -1 z)) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (* -1 (/ (* z (+ (* -1 (/ (pow z 2) y)) (/ (pow z 2) y))) (* i y))) (+ (* -1 (/ (pow z 2) y)) (/ (pow z 2) y))) i)) (* -1 z)) i)))))
(/ 1 (* i y))
(+ (* -1 (/ z (* (pow i 2) (pow y 2)))) (/ 1 (* i y)))
(+ (* z (- (/ z (* (pow i 3) (pow y 3))) (/ 1 (* (pow i 2) (pow y 2))))) (/ 1 (* i y)))
(+ (* z (- (* z (+ (* -1 (/ z (* (pow i 4) (pow y 4)))) (/ 1 (* (pow i 3) (pow y 3))))) (/ 1 (* (pow i 2) (pow y 2))))) (/ 1 (* i y)))
(/ 1 z)
(/ (+ 1 (* -1 (/ (* i y) z))) z)
(/ (+ 1 (+ (* -1 (/ (* i y) z)) (/ (* (pow i 2) (pow y 2)) (pow z 2)))) z)
(/ (+ 1 (+ (* -1 (/ (* i y) z)) (+ (* -1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) (/ (* (pow i 2) (pow y 2)) (pow z 2))))) z)
(/ 1 z)
(* -1 (/ (- (/ (* i y) z) 1) z))
(* -1 (/ (- (* -1 (/ (+ (* -1 (* i y)) (/ (* (pow i 2) (pow y 2)) z)) z)) 1) z))
(* -1 (/ (- (* -1 (/ (+ (* -1 (* i y)) (* -1 (/ (+ (* -1 (* (pow i 2) (pow y 2))) (/ (* (pow i 3) (pow y 3)) z)) z))) z)) 1) z))
(/ 1 z)
(+ (* -1 (/ (* i y) (pow z 2))) (/ 1 z))
(+ (* y (+ (* -1 (/ i (pow z 2))) (/ (* (pow i 2) y) (pow z 3)))) (/ 1 z))
(+ (* y (+ (* -1 (/ i (pow z 2))) (* y (+ (* -1 (/ (* (pow i 3) y) (pow z 4))) (/ (pow i 2) (pow z 3)))))) (/ 1 z))
(/ 1 (* i y))
(/ (+ (* -1 (/ z (* (pow i 2) y))) (/ 1 i)) y)
(/ (+ (* -1 (/ z (* (pow i 2) y))) (+ (/ 1 i) (/ (pow z 2) (* (pow i 3) (pow y 2))))) y)
(/ (+ (* -1 (/ z (* (pow i 2) y))) (+ (* -1 (/ (pow z 3) (* (pow i 4) (pow y 3)))) (+ (/ 1 i) (/ (pow z 2) (* (pow i 3) (pow y 2)))))) y)
(/ 1 (* i y))
(* -1 (/ (- (/ z (* (pow i 2) y)) (/ 1 i)) y))
(* -1 (/ (- (* -1 (/ (+ (* -1 (/ z (pow i 2))) (/ (pow z 2) (* (pow i 3) y))) y)) (/ 1 i)) y))
(* -1 (/ (- (* -1 (/ (+ (* -1 (/ z (pow i 2))) (* -1 (/ (+ (* -1 (/ (pow z 2) (pow i 3))) (/ (pow z 3) (* (pow i 4) y))) y))) y)) (/ 1 i)) y))
(/ 1 z)
(+ (* -1 (/ (* i y) (pow z 2))) (/ 1 z))
(+ (* i (+ (* -1 (/ y (pow z 2))) (/ (* i (pow y 2)) (pow z 3)))) (/ 1 z))
(+ (* i (+ (* -1 (/ y (pow z 2))) (* i (+ (* -1 (/ (* i (pow y 3)) (pow z 4))) (/ (pow y 2) (pow z 3)))))) (/ 1 z))
(/ 1 (* i y))
(/ (+ (* -1 (/ z (* i (pow y 2)))) (/ 1 y)) i)
(/ (+ (* -1 (/ z (* i (pow y 2)))) (+ (/ 1 y) (/ (pow z 2) (* (pow i 2) (pow y 3))))) i)
(/ (+ (* -1 (/ z (* i (pow y 2)))) (+ (* -1 (/ (pow z 3) (* (pow i 3) (pow y 4)))) (+ (/ 1 y) (/ (pow z 2) (* (pow i 2) (pow y 3)))))) i)
(/ 1 (* i y))
(* -1 (/ (- (/ z (* i (pow y 2))) (/ 1 y)) i))
(* -1 (/ (- (* -1 (/ (+ (* -1 (/ z (pow y 2))) (/ (pow z 2) (* i (pow y 3)))) i)) (/ 1 y)) i))
(* -1 (/ (- (* -1 (/ (+ (* -1 (/ z (pow y 2))) (* -1 (/ (+ (* -1 (/ (pow z 2) (pow y 3))) (/ (pow z 3) (* i (pow y 4)))) i))) i)) (/ 1 y)) i))
(* (pow i 2) (pow y 2))
(+ (* -1 (* i (* y z))) (* (pow i 2) (pow y 2)))
(+ (* z (+ z (* -1 (* i y)))) (* (pow i 2) (pow y 2)))
(+ (* z (+ z (* -1 (* i y)))) (* (pow i 2) (pow y 2)))
(pow z 2)
(* (pow z 2) (+ 1 (* -1 (/ (* i y) z))))
(* (pow z 2) (+ 1 (+ (* -1 (/ (* i y) z)) (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(* (pow z 2) (+ 1 (+ (* -1 (/ (* i y) z)) (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(pow z 2)
(* (pow z 2) (+ 1 (* -1 (/ (* i y) z))))
(* (pow z 2) (+ 1 (* -1 (/ (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y)) z))))
(* (pow z 2) (+ 1 (* -1 (/ (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y)) z))))
(pow z 2)
(+ (* -1 (* i (* y z))) (pow z 2))
(+ (* y (+ (* -1 (* i z)) (* (pow i 2) y))) (pow z 2))
(+ (* y (+ (* -1 (* i z)) (* (pow i 2) y))) (pow z 2))
(* (pow i 2) (pow y 2))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (+ (/ (pow z 2) (pow y 2)) (pow i 2))))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (+ (/ (pow z 2) (pow y 2)) (pow i 2))))
(* (pow i 2) (pow y 2))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(* (pow y 2) (+ (* -1 (/ (+ (* -1 (/ (pow z 2) y)) (* i z)) y)) (pow i 2)))
(* (pow y 2) (+ (* -1 (/ (+ (* -1 (/ (pow z 2) y)) (* i z)) y)) (pow i 2)))
(pow z 2)
(+ (* -1 (* i (* y z))) (pow z 2))
(+ (* i (+ (* -1 (* y z)) (* i (pow y 2)))) (pow z 2))
(+ (* i (+ (* -1 (* y z)) (* i (pow y 2)))) (pow z 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (+ (/ (pow z 2) (pow i 2)) (pow y 2))))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (+ (/ (pow z 2) (pow i 2)) (pow y 2))))
(* (pow i 2) (pow y 2))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(* (pow i 2) (+ (* -1 (/ (+ (* -1 (/ (pow z 2) i)) (* y z)) i)) (pow y 2)))
(* (pow i 2) (+ (* -1 (/ (+ (* -1 (/ (pow z 2) i)) (* y z)) i)) (pow y 2)))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ a (+ z (* -1/2 (log c))))
(+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))
(+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))
(+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))
(+ z (* (log c) (- b 1/2)))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
a
(* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
a
(* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))
(+ a (* (log c) (- b 1/2)))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
(+ a (+ z (* (log c) (- b 1/2))))
z
(* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))
(* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))
(* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))
z
(* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* -1/2 (log c))
(+ (* -1/2 (log c)) (* b (log c)))
(+ (* -1/2 (log c)) (* b (log c)))
(+ (* -1/2 (log c)) (* b (log c)))
(* b (log c))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(log c)
(log c)
(log c)
(log c)
(* -1 (log (/ 1 c)))
(* -1 (log (/ 1 c)))
(* -1 (log (/ 1 c)))
(* -1 (log (/ 1 c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ (log -1) (* -1 (log (/ -1 c))))
-1/2
(- b 1/2)
(- b 1/2)
(- b 1/2)
b
(* b (- 1 (* 1/2 (/ 1 b))))
(* b (- 1 (* 1/2 (/ 1 b))))
(* b (- 1 (* 1/2 (/ 1 b))))
b
(* -1 (* b (- (* 1/2 (/ 1 b)) 1)))
(* -1 (* b (- (* 1/2 (/ 1 b)) 1)))
(* -1 (* b (- (* 1/2 (/ 1 b)) 1)))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(pow z 3)
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(* (pow i 3) (pow y 3))
(* (pow y 3) (+ (/ (pow z 3) (pow y 3)) (pow i 3)))
(* (pow y 3) (+ (/ (pow z 3) (pow y 3)) (pow i 3)))
(* (pow y 3) (+ (/ (pow z 3) (pow y 3)) (pow i 3)))
(* (pow i 3) (pow y 3))
(* -1 (* (pow y 3) (+ (* -1 (/ (pow z 3) (pow y 3))) (* -1 (pow i 3)))))
(* -1 (* (pow y 3) (+ (* -1 (/ (pow z 3) (pow y 3))) (* -1 (pow i 3)))))
(* -1 (* (pow y 3) (+ (* -1 (/ (pow z 3) (pow y 3))) (* -1 (pow i 3)))))
(pow z 3)
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(* (pow i 3) (pow y 3))
(* (pow i 3) (+ (/ (pow z 3) (pow i 3)) (pow y 3)))
(* (pow i 3) (+ (/ (pow z 3) (pow i 3)) (pow y 3)))
(* (pow i 3) (+ (/ (pow z 3) (pow i 3)) (pow y 3)))
(* (pow i 3) (pow y 3))
(* -1 (* (pow i 3) (+ (* -1 (/ (pow z 3) (pow i 3))) (* -1 (pow y 3)))))
(* -1 (* (pow i 3) (+ (* -1 (/ (pow z 3) (pow i 3))) (* -1 (pow y 3)))))
(* -1 (* (pow i 3) (+ (* -1 (/ (pow z 3) (pow i 3))) (* -1 (pow y 3)))))
(* (pow i 3) (pow y 3))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(pow z 3)
(* (pow z 3) (+ 1 (/ (* (pow i 3) (pow y 3)) (pow z 3))))
(* (pow z 3) (+ 1 (/ (* (pow i 3) (pow y 3)) (pow z 3))))
(* (pow z 3) (+ 1 (/ (* (pow i 3) (pow y 3)) (pow z 3))))
(pow z 3)
(* -1 (* (pow z 3) (- (* -1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) 1)))
(* -1 (* (pow z 3) (- (* -1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) 1)))
(* -1 (* (pow z 3) (- (* -1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) 1)))
(* -1 (* i (* y z)))
(* y (+ (* -1 (* i z)) (* (pow i 2) y)))
(* y (+ (* -1 (* i z)) (* (pow i 2) y)))
(* y (+ (* -1 (* i z)) (* (pow i 2) y)))
(* (pow i 2) (pow y 2))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(* (pow i 2) (pow y 2))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(* -1 (* i (* y z)))
(* i (+ (* -1 (* y z)) (* i (pow y 2))))
(* i (+ (* -1 (* y z)) (* i (pow y 2))))
(* i (+ (* -1 (* y z)) (* i (pow y 2))))
(* (pow i 2) (pow y 2))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(* (pow i 2) (pow y 2))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(* (pow i 2) (pow y 2))
(+ (* -1 (* i (* y z))) (* (pow i 2) (pow y 2)))
(+ (* -1 (* i (* y z))) (* (pow i 2) (pow y 2)))
(+ (* -1 (* i (* y z))) (* (pow i 2) (pow y 2)))
(* -1 (* i (* y z)))
(* z (+ (* -1 (* i y)) (/ (* (pow i 2) (pow y 2)) z)))
(* z (+ (* -1 (* i y)) (/ (* (pow i 2) (pow y 2)) z)))
(* z (+ (* -1 (* i y)) (/ (* (pow i 2) (pow y 2)) z)))
(* -1 (* i (* y z)))
(* -1 (* z (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y))))
(* -1 (* z (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y))))
(* -1 (* z (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y))))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
(* (pow i 2) (pow y 2))
z
(+ a z)
(+ a z)
(+ a z)
a
(* a (+ 1 (/ z a)))
(* a (+ 1 (/ z a)))
(* a (+ 1 (/ z a)))
a
(* -1 (* a (- (* -1 (/ z a)) 1)))
(* -1 (* a (- (* -1 (/ z a)) 1)))
(* -1 (* a (- (* -1 (/ z a)) 1)))
a
(+ a z)
(+ a z)
(+ a z)
z
(* z (+ 1 (/ a z)))
(* z (+ 1 (/ a z)))
(* z (+ 1 (/ a z)))
z
(* -1 (* z (- (* -1 (/ a z)) 1)))
(* -1 (* z (- (* -1 (/ a z)) 1)))
(* -1 (* z (- (* -1 (/ a z)) 1)))
Outputs
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 t a) (+.f64 (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 t a) (+.f64 (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 t a) (+.f64 (+.f64 (/.f64 z a) (/.f64 (*.f64 x (log.f64 y)) a)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 z (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(*.f64 t (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 z t)) (/.f64 a t)) (+.f64 (/.f64 (*.f64 x (log.f64 y)) t) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) t)))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(*.f64 t (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 z t)) (/.f64 a t)) (+.f64 (/.f64 (*.f64 x (log.f64 y)) t) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) t)))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(*.f64 t (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 z t)) (/.f64 a t)) (+.f64 (/.f64 (*.f64 x (log.f64 y)) t) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) t)))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 z (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) a) (neg.f64 t)) #s(literal -1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 z (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) a) (neg.f64 t)) #s(literal -1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 z (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) a) (neg.f64 t)) #s(literal -1 binary64)) (neg.f64 t))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 t (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(*.f64 z (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t z)) (/.f64 a z)) (+.f64 (/.f64 (*.f64 x (log.f64 y)) z) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(*.f64 z (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t z)) (/.f64 a z)) (+.f64 (/.f64 (*.f64 x (log.f64 y)) z) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(*.f64 z (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t z)) (/.f64 a z)) (+.f64 (/.f64 (*.f64 x (log.f64 y)) z) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z)))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 a (+.f64 t (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 a (+.f64 t (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 a (+.f64 t (+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t a) (+.f64 z (*.f64 x (log.f64 y)))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t a) (+.f64 z (*.f64 x (log.f64 y)))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t a) (+.f64 z (*.f64 x (log.f64 y)))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t a) (+.f64 z (*.f64 x (log.f64 y)))) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+.f64 (+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (*.f64 x (log.f64 y)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (/.f64 a b)) (/.f64 t b)) (+.f64 (/.f64 z b) (/.f64 (*.f64 x (log.f64 y)) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (/.f64 a b)) (/.f64 t b)) (+.f64 (/.f64 z b) (/.f64 (*.f64 x (log.f64 y)) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (/.f64 a b)) (/.f64 t b)) (+.f64 (/.f64 z b) (/.f64 (*.f64 x (log.f64 y)) b)))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 c)) (/.f64 (+.f64 (+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (*.f64 x (log.f64 y))) b)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 c)) (/.f64 (+.f64 (+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (*.f64 x (log.f64 y))) b)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 c)) (/.f64 (+.f64 (+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) (*.f64 x (log.f64 y))) b)) (neg.f64 b))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(* x (log y))
(*.f64 x (log.f64 y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (+.f64 (/.f64 a x) (+.f64 (/.f64 t x) (/.f64 z x))) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (+.f64 (/.f64 a x) (+.f64 (/.f64 t x) (/.f64 z x))) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 x (+.f64 (log.f64 y) (+.f64 (+.f64 (/.f64 a x) (+.f64 (/.f64 t x) (/.f64 z x))) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) x))))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (-.f64 (log.f64 (/.f64 #s(literal 1 binary64) y)) (/.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) x)) (neg.f64 x))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (-.f64 (log.f64 (/.f64 #s(literal 1 binary64) y)) (/.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) x)) (neg.f64 x))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (-.f64 (log.f64 (/.f64 #s(literal 1 binary64) y)) (/.f64 (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) x)) (neg.f64 x))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) a)
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a (+.f64 t z)) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (neg.f64 (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a (+.f64 t z)) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (neg.f64 (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a (+.f64 t z)) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (neg.f64 (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a (+.f64 t z)) (-.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (neg.f64 (*.f64 x (log.f64 y)))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a (+.f64 t z)) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))))
(+ t (+ z (* (log c) (- b 1/2))))
(+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))
(*.f64 a (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t a)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) (/.f64 z a)))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))
(*.f64 a (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t a)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) (/.f64 z a)))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))
(*.f64 a (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t a)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)) (/.f64 z a)))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (* (log c) (- b 1/2)))) a)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ t (+ z (* (log c) (- b 1/2)))) a)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ t (+ z (* (log c) (- b 1/2)))) a)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* (log c) (- b 1/2)) t)))))
(*.f64 t (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 a t) (+.f64 (/.f64 z t) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* (log c) (- b 1/2)) t)))))
(*.f64 t (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 a t) (+.f64 (/.f64 z t) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* (log c) (- b 1/2)) t)))))
(*.f64 t (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 a t) (+.f64 (/.f64 z t) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) t)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (neg.f64 t)) #s(literal -1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) t)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (neg.f64 t)) #s(literal -1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a (+ z (* (log c) (- b 1/2)))) t)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (neg.f64 t)) #s(literal -1 binary64)) (neg.f64 t))
(+ a (+ t (* (log c) (- b 1/2))))
(+.f64 (+.f64 t a) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* (log c) (- b 1/2)) z)))))
(*.f64 z (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))) (/.f64 t z)))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* (log c) (- b 1/2)) z)))))
(*.f64 z (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))) (/.f64 t z)))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* (log c) (- b 1/2)) z)))))
(*.f64 z (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))) (/.f64 t z)))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (* (log c) (- b 1/2)))) z)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ a (+ t (* (log c) (- b 1/2)))) z)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ a (+ t (* (log c) (- b 1/2)))) z)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* -1 (* (log (/ 1 c)) (- b 1/2))))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* -1 (* (log (/ 1 c)) (- b 1/2))))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* -1 (* (log (/ 1 c)) (- b 1/2))))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* -1 (* (log (/ 1 c)) (- b 1/2))))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+.f64 (+.f64 a (+.f64 t z)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+.f64 (+.f64 a (+.f64 t z)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+.f64 (+.f64 a (+.f64 t z)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))
(+.f64 (+.f64 a (+.f64 t z)) (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))))
(+ a (+ t (+ z (* -1/2 (log c)))))
(+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* b (log c))))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* b (log c))))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* b (log c))))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (/ z b))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (+.f64 (/.f64 t b) (/.f64 z b))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (/ z b))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (+.f64 (/.f64 t b) (/.f64 z b))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (/ z b))))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (+.f64 (/.f64 t b) (/.f64 z b))))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (* -1/2 (log c))))) b)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 c)) (/.f64 (+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) b)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (* -1/2 (log c))))) b)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 c)) (/.f64 (+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) b)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (* -1/2 (log c))))) b)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 c)) (/.f64 (+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64))))) b)) (neg.f64 b))
(+ t z)
(+.f64 t z)
(+ a (+ t z))
(+.f64 a (+.f64 t z))
(+ a (+ t z))
(+.f64 a (+.f64 t z))
(+ a (+ t z))
(+.f64 a (+.f64 t z))
a
(* a (+ 1 (+ (/ t a) (/ z a))))
(*.f64 a (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 z a)) (/.f64 t a)))
(* a (+ 1 (+ (/ t a) (/ z a))))
(*.f64 a (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 z a)) (/.f64 t a)))
(* a (+ 1 (+ (/ t a) (/ z a))))
(*.f64 a (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 z a)) (/.f64 t a)))
a
(* -1 (* a (- (* -1 (/ (+ t z) a)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 t z) a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ t z) a)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 t z) a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ t z) a)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 t z) a)) #s(literal -1 binary64)) (neg.f64 a))
(+ a z)
(+.f64 z a)
(+ a (+ t z))
(+.f64 a (+.f64 t z))
(+ a (+ t z))
(+.f64 a (+.f64 t z))
(+ a (+ t z))
(+.f64 a (+.f64 t z))
t
(* t (+ 1 (+ (/ a t) (/ z t))))
(*.f64 t (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 z t)) (/.f64 a t)))
(* t (+ 1 (+ (/ a t) (/ z t))))
(*.f64 t (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 z t)) (/.f64 a t)))
(* t (+ 1 (+ (/ a t) (/ z t))))
(*.f64 t (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 z t)) (/.f64 a t)))
t
(* -1 (* t (- (* -1 (/ (+ a z) t)) 1)))
(*.f64 (*.f64 (+.f64 (/.f64 (+.f64 z a) t) #s(literal 1 binary64)) #s(literal -1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a z) t)) 1)))
(*.f64 (*.f64 (+.f64 (/.f64 (+.f64 z a) t) #s(literal 1 binary64)) #s(literal -1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a z) t)) 1)))
(*.f64 (*.f64 (+.f64 (/.f64 (+.f64 z a) t) #s(literal 1 binary64)) #s(literal -1 binary64)) (neg.f64 t))
(+ a t)
(+.f64 t a)
(+ a (+ t z))
(+.f64 a (+.f64 t z))
(+ a (+ t z))
(+.f64 a (+.f64 t z))
(+ a (+ t z))
(+.f64 a (+.f64 t z))
z
(* z (+ 1 (+ (/ a z) (/ t z))))
(*.f64 z (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t z)) (/.f64 a z)))
(* z (+ 1 (+ (/ a z) (/ t z))))
(*.f64 z (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t z)) (/.f64 a z)))
(* z (+ 1 (+ (/ a z) (/ t z))))
(*.f64 z (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t z)) (/.f64 a z)))
z
(* -1 (* z (- (* -1 (/ (+ a t) z)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 t a) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ a t) z)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 t a) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ a t) z)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 t a) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
z
(+ t z)
(+.f64 t z)
(+ t z)
(+.f64 t z)
(+ t z)
(+.f64 t z)
t
(* t (+ 1 (/ z t)))
(*.f64 t (+.f64 #s(literal 1 binary64) (/.f64 z t)))
(* t (+ 1 (/ z t)))
(*.f64 t (+.f64 #s(literal 1 binary64) (/.f64 z t)))
(* t (+ 1 (/ z t)))
(*.f64 t (+.f64 #s(literal 1 binary64) (/.f64 z t)))
t
(* -1 (* t (- (* -1 (/ z t)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 z t)) #s(literal -1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ z t)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 z t)) #s(literal -1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ z t)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 z t)) #s(literal -1 binary64)) (neg.f64 t))
t
(+ t z)
(+.f64 t z)
(+ t z)
(+.f64 t z)
(+ t z)
(+.f64 t z)
z
(* z (+ 1 (/ t z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 t z)))
(* z (+ 1 (/ t z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 t z)))
(* z (+ 1 (/ t z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 t z)))
z
(* -1 (* z (- (* -1 (/ t z)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 t z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ t z)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 t z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ t z)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 t z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* -1 (/ (pow z 2) (* i y)))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(* (pow z 2) (- (* -1 (/ z (* (pow i 2) (pow y 2)))) (/ 1 (* i y))))
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(* (pow z 2) (- (* z (- (* -1 (/ z (* (pow i 3) (pow y 3)))) (/ 1 (* (pow i 2) (pow y 2))))) (/ 1 (* i y))))
(*.f64 (*.f64 z z) (+.f64 (*.f64 z (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y)))) (/.f64 #s(literal -1 binary64) (*.f64 (*.f64 y i) (*.f64 y i))))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(* (pow z 2) (- (* z (- (* z (- (* -1 (/ z (* (pow i 4) (pow y 4)))) (/ 1 (* (pow i 3) (pow y 3))))) (/ 1 (* (pow i 2) (pow y 2))))) (/ 1 (* i y))))
(*.f64 (*.f64 z z) (+.f64 (*.f64 z (+.f64 (*.f64 z (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (pow.f64 i #s(literal 4 binary64)) (pow.f64 y #s(literal 4 binary64)))) (/.f64 #s(literal -1 binary64) (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y)))))) (/.f64 #s(literal -1 binary64) (*.f64 (*.f64 y i) (*.f64 y i))))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
z
(* z (+ 1 (/ (* i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(* z (- (+ 1 (/ (* (pow i 2) (pow y 2)) (pow z 2))) (* -1 (/ (* i y) z))))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z z)) (/.f64 (*.f64 y i) z))))
(* z (- (+ 1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) (+ (* -1 (/ (* i y) z)) (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2))))))
(*.f64 z (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))) (*.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 y i) z) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z z))))))
z
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 y i) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (- (/ (* (pow i 2) (pow y 2)) z) (* -1 (* i y))) z)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (- (* -1 (/ (- (* -1 (/ (* (pow i 3) (pow y 3)) z)) (* (pow i 2) (pow y 2))) z)) (* -1 (* i y))) z)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (-.f64 #s(literal 0 binary64) z)) (*.f64 (*.f64 y i) (*.f64 y i))) (-.f64 #s(literal 0 binary64) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
z
(+ z (* i y))
(+.f64 z (*.f64 y i))
(+ z (* y (- (/ (* (pow i 2) y) z) (* -1 i))))
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
(+ z (* y (- (* y (- (/ (* (pow i 3) y) (pow z 2)) (* -1 (/ (pow i 2) z)))) (* -1 i))))
(+.f64 z (*.f64 y (+.f64 (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i (*.f64 i i))) (*.f64 z z)) (/.f64 (*.f64 i i) z))) i)))
(* -1 (/ (pow z 2) (* i y)))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/ (+ (* -1 (/ (pow z 2) i)) (* -1 (/ (pow z 3) (* (pow i 2) y)))) y)
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(/ (- (+ (* -1 (/ (pow z 2) i)) (* -1 (/ (pow z 4) (* (pow i 3) (pow y 2))))) (/ (pow z 3) (* (pow i 2) y))) y)
(/.f64 (-.f64 (-.f64 (/.f64 (/.f64 (pow.f64 z #s(literal 4 binary64)) (*.f64 i (*.f64 i i))) (*.f64 #s(literal -1 binary64) (*.f64 y y))) (/.f64 (*.f64 z z) i)) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) y)
(/ (- (+ (* -1 (/ (pow z 2) i)) (* -1 (/ (pow z 5) (* (pow i 4) (pow y 3))))) (+ (/ (pow z 3) (* (pow i 2) y)) (/ (pow z 4) (* (pow i 3) (pow y 2))))) y)
(/.f64 (-.f64 (-.f64 (-.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 z z) i)) (/.f64 (pow.f64 z #s(literal 5 binary64)) (*.f64 (*.f64 y (*.f64 y y)) (pow.f64 i #s(literal 4 binary64))))) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (/.f64 (/.f64 (pow.f64 z #s(literal 4 binary64)) (*.f64 i (*.f64 i i))) (*.f64 y y))) y)
(* -1 (/ (pow z 2) (* i y)))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(* -1 (/ (+ (/ (pow z 2) i) (/ (pow z 3) (* (pow i 2) y))) y))
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(* -1 (/ (+ (* -1 (/ (- (* -1 (/ (pow z 4) (* (pow i 3) y))) (/ (pow z 3) (pow i 2))) y)) (/ (pow z 2) i)) y))
(/.f64 (-.f64 (/.f64 (*.f64 z z) i) (/.f64 (-.f64 (/.f64 (/.f64 (pow.f64 z #s(literal 4 binary64)) (*.f64 i (*.f64 i i))) (-.f64 #s(literal 0 binary64) y)) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 i i))) y)) (-.f64 #s(literal 0 binary64) y))
(* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (pow z 5) (* (pow i 4) y)) (* -1 (/ (pow z 4) (pow i 3)))) y)) (/ (pow z 3) (pow i 2))) y)) (/ (pow z 2) i)) y))
(/.f64 (-.f64 (/.f64 (*.f64 z z) i) (/.f64 (-.f64 (/.f64 (+.f64 (/.f64 (pow.f64 z #s(literal 5 binary64)) (*.f64 y (pow.f64 i #s(literal 4 binary64)))) (/.f64 (pow.f64 z #s(literal 4 binary64)) (*.f64 i (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y)) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 i i))) y)) (-.f64 #s(literal 0 binary64) y))
z
(+ z (* i y))
(+.f64 z (*.f64 y i))
(+ z (* i (- (/ (* i (pow y 2)) z) (* -1 y))))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
(+ z (* i (- (* i (- (/ (* i (pow y 3)) (pow z 2)) (* -1 (/ (pow y 2) z)))) (* -1 y))))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (+.f64 (/.f64 (*.f64 i (*.f64 y (*.f64 y y))) (*.f64 z z)) (/.f64 (*.f64 y y) z))) y)))
(* -1 (/ (pow z 2) (* i y)))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/ (+ (* -1 (/ (pow z 2) y)) (* -1 (/ (pow z 3) (* i (pow y 2))))) i)
(/.f64 (+.f64 (/.f64 (*.f64 z z) y) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 i (*.f64 y y)))) (-.f64 #s(literal 0 binary64) i))
(/ (- (+ (* -1 (/ (pow z 2) y)) (* -1 (/ (pow z 4) (* (pow i 2) (pow y 3))))) (/ (pow z 3) (* i (pow y 2)))) i)
(/.f64 (-.f64 (-.f64 (*.f64 (/.f64 #s(literal -1 binary64) (*.f64 i i)) (/.f64 (pow.f64 z #s(literal 4 binary64)) (*.f64 y (*.f64 y y)))) (/.f64 (*.f64 z z) y)) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 i (*.f64 y y)))) i)
(/ (- (+ (* -1 (/ (pow z 2) y)) (* -1 (/ (pow z 5) (* (pow i 3) (pow y 4))))) (+ (/ (pow z 3) (* i (pow y 2))) (/ (pow z 4) (* (pow i 2) (pow y 3))))) i)
(/.f64 (-.f64 (-.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 z z) y)) (/.f64 (pow.f64 z #s(literal 5 binary64)) (*.f64 (*.f64 i (*.f64 i i)) (pow.f64 y #s(literal 4 binary64))))) (+.f64 (/.f64 (*.f64 z (*.f64 z z)) (*.f64 i (*.f64 y y))) (/.f64 (pow.f64 z #s(literal 4 binary64)) (*.f64 (*.f64 i i) (*.f64 y (*.f64 y y)))))) i)
(* -1 (/ (pow z 2) (* i y)))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(* -1 (/ (+ (/ (pow z 2) y) (/ (pow z 3) (* i (pow y 2)))) i))
(/.f64 (+.f64 (/.f64 (*.f64 z z) y) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 i (*.f64 y y)))) (-.f64 #s(literal 0 binary64) i))
(* -1 (/ (+ (* -1 (/ (- (* -1 (/ (pow z 4) (* i (pow y 3)))) (/ (pow z 3) (pow y 2))) i)) (/ (pow z 2) y)) i))
(/.f64 (-.f64 (/.f64 (*.f64 z z) y) (/.f64 (-.f64 (/.f64 (pow.f64 z #s(literal 4 binary64)) (neg.f64 (*.f64 i (*.f64 y (*.f64 y y))))) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y y))) i)) (-.f64 #s(literal 0 binary64) i))
(* -1 (/ (+ (* -1 (/ (- (* -1 (/ (- (/ (pow z 5) (* i (pow y 4))) (* -1 (/ (pow z 4) (pow y 3)))) i)) (/ (pow z 3) (pow y 2))) i)) (/ (pow z 2) y)) i))
(/.f64 (-.f64 (/.f64 (*.f64 z z) y) (/.f64 (-.f64 (/.f64 (+.f64 (/.f64 (/.f64 (pow.f64 z #s(literal 5 binary64)) i) (pow.f64 y #s(literal 4 binary64))) (/.f64 (pow.f64 z #s(literal 4 binary64)) (*.f64 y (*.f64 y y)))) (-.f64 #s(literal 0 binary64) i)) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y y))) i)) (-.f64 #s(literal 0 binary64) i))
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(pow z 2)
(*.f64 z z)
(* -1 (* i y))
(-.f64 #s(literal 0 binary64) (*.f64 y i))
(- z (* i y))
(-.f64 z (*.f64 y i))
(- z (* i y))
(-.f64 z (*.f64 y i))
(- z (* i y))
(-.f64 z (*.f64 y i))
z
(* z (+ 1 (* -1 (/ (* i y) z))))
(*.f64 z (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(* z (+ 1 (* -1 (/ (* i y) z))))
(*.f64 z (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(* z (+ 1 (* -1 (/ (* i y) z))))
(*.f64 z (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
z
(* -1 (* z (- (/ (* i y) z) 1)))
(*.f64 z (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(* -1 (* z (- (/ (* i y) z) 1)))
(*.f64 z (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(* -1 (* z (- (/ (* i y) z) 1)))
(*.f64 z (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
z
(+ z (* -1 (* i y)))
(-.f64 z (*.f64 y i))
(+ z (* -1 (* i y)))
(-.f64 z (*.f64 y i))
(+ z (* -1 (* i y)))
(-.f64 z (*.f64 y i))
(* -1 (* i y))
(-.f64 #s(literal 0 binary64) (*.f64 y i))
(* y (- (/ z y) i))
(*.f64 y (-.f64 (/.f64 z y) i))
(* y (- (/ z y) i))
(*.f64 y (-.f64 (/.f64 z y) i))
(* y (- (/ z y) i))
(*.f64 y (-.f64 (/.f64 z y) i))
(* -1 (* i y))
(-.f64 #s(literal 0 binary64) (*.f64 y i))
(* -1 (* y (- (* -1 (/ z y)) (* -1 i))))
(-.f64 #s(literal 0 binary64) (*.f64 y (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) y)) i)))
(* -1 (* y (- (* -1 (/ z y)) (* -1 i))))
(-.f64 #s(literal 0 binary64) (*.f64 y (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) y)) i)))
(* -1 (* y (- (* -1 (/ z y)) (* -1 i))))
(-.f64 #s(literal 0 binary64) (*.f64 y (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) y)) i)))
z
(+ z (* -1 (* i y)))
(-.f64 z (*.f64 y i))
(+ z (* -1 (* i y)))
(-.f64 z (*.f64 y i))
(+ z (* -1 (* i y)))
(-.f64 z (*.f64 y i))
(* -1 (* i y))
(-.f64 #s(literal 0 binary64) (*.f64 y i))
(* i (- (/ z i) y))
(*.f64 i (-.f64 (/.f64 z i) y))
(* i (- (/ z i) y))
(*.f64 i (-.f64 (/.f64 z i) y))
(* i (- (/ z i) y))
(*.f64 i (-.f64 (/.f64 z i) y))
(* -1 (* i y))
(-.f64 #s(literal 0 binary64) (*.f64 y i))
(* -1 (* i (- (* -1 (/ z i)) (* -1 y))))
(-.f64 #s(literal 0 binary64) (*.f64 i (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) i)) y)))
(* -1 (* i (- (* -1 (/ z i)) (* -1 y))))
(-.f64 #s(literal 0 binary64) (*.f64 i (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) i)) y)))
(* -1 (* i (- (* -1 (/ z i)) (* -1 y))))
(-.f64 #s(literal 0 binary64) (*.f64 i (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) i)) y)))
(* i y)
(*.f64 y i)
(+ z (* i y))
(+.f64 z (*.f64 y i))
(+ z (* i y))
(+.f64 z (*.f64 y i))
(+ z (* i y))
(+.f64 z (*.f64 y i))
z
(* z (+ 1 (/ (* i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(* z (- (+ 1 (* -1 (/ (+ (* -1 (* (pow i 2) (pow y 2))) (* (pow i 2) (pow y 2))) (pow z 2)))) (* -1 (/ (* i y) z))))
(*.f64 z (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(literal 0 binary64) (*.f64 z z))) (/.f64 (*.f64 y i) z)))
(* z (- (+ 1 (* -1 (/ (* i (* y (+ (* -1 (* (pow i 2) (pow y 2))) (* (pow i 2) (pow y 2))))) (pow z 3)))) (+ (* -1 (/ (* i y) z)) (+ (* -1 (/ (* (pow i 2) (pow y 2)) (pow z 2))) (/ (* (pow i 2) (pow y 2)) (pow z 2))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 i (*.f64 y #s(literal 0 binary64))) (*.f64 z (*.f64 z z)))) (/.f64 (*.f64 y i) z)))
z
(* -1 (* z (- (* -1 (/ (* i y) z)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 y i) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (- (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (/ (* (pow i 2) (pow y 2)) z)) (* -1 (* i y))) z)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 y i) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (- (* -1 (/ (- (* -1 (/ (* i (* y (+ (* -1 (* (pow i 2) (pow y 2))) (* (pow i 2) (pow y 2))))) z)) (+ (* -1 (* (pow i 2) (pow y 2))) (* (pow i 2) (pow y 2)))) z)) (* -1 (* i y))) z)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (*.f64 i (*.f64 y #s(literal 0 binary64))) (-.f64 #s(literal 0 binary64) z)) #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
z
(+ z (* i y))
(+.f64 z (*.f64 y i))
(+ z (* y (- (* -1 (* y (+ (* -1 (/ (pow i 2) z)) (/ (pow i 2) z)))) (* -1 i))))
(+.f64 z (*.f64 y (+.f64 (*.f64 y #s(literal 0 binary64)) i)))
(+ z (* y (- (* y (- (* -1 (/ (* i (* y (+ (* -1 (/ (pow i 2) z)) (/ (pow i 2) z)))) z)) (+ (* -1 (/ (pow i 2) z)) (/ (pow i 2) z)))) (* -1 i))))
(+.f64 z (*.f64 y (+.f64 (*.f64 y (+.f64 (/.f64 (*.f64 i (*.f64 y #s(literal 0 binary64))) (-.f64 #s(literal 0 binary64) z)) #s(literal 0 binary64))) i)))
(* i y)
(*.f64 y i)
(* y (+ i (/ z y)))
(*.f64 y (+.f64 i (/.f64 z y)))
(* y (- (+ i (* -1 (/ (+ (* -1 (/ (pow z 2) i)) (/ (pow z 2) i)) (pow y 2)))) (* -1 (/ z y))))
(*.f64 y (+.f64 (+.f64 i (/.f64 #s(literal 0 binary64) (*.f64 y y))) (/.f64 z y)))
(* y (- (+ i (* -1 (/ (* z (+ (* -1 (/ (pow z 2) i)) (/ (pow z 2) i))) (* i (pow y 3))))) (+ (* -1 (/ z y)) (+ (* -1 (/ (pow z 2) (* i (pow y 2)))) (/ (pow z 2) (* i (pow y 2)))))))
(*.f64 y (+.f64 (-.f64 i (/.f64 (*.f64 z #s(literal 0 binary64)) (*.f64 i (*.f64 y (*.f64 y y))))) (/.f64 z y)))
(* i y)
(*.f64 y i)
(* -1 (* y (+ (* -1 i) (* -1 (/ z y)))))
(-.f64 #s(literal 0 binary64) (*.f64 y (-.f64 (/.f64 z (-.f64 #s(literal 0 binary64) y)) i)))
(* -1 (* y (+ (* -1 i) (* -1 (/ (- (+ (* -1 (/ (pow z 2) (* i y))) (/ (pow z 2) (* i y))) (* -1 z)) y)))))
(-.f64 #s(literal 0 binary64) (*.f64 y (-.f64 (/.f64 z (-.f64 #s(literal 0 binary64) y)) i)))
(* -1 (* y (+ (* -1 i) (* -1 (/ (- (* -1 (/ (- (* -1 (/ (* z (+ (* -1 (/ (pow z 2) i)) (/ (pow z 2) i))) (* i y))) (+ (* -1 (/ (pow z 2) i)) (/ (pow z 2) i))) y)) (* -1 z)) y)))))
(*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 (-.f64 #s(literal 0 binary64) i) (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (*.f64 z #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 y i))) #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) y)) z) y)))
z
(+ z (* i y))
(+.f64 z (*.f64 y i))
(+ z (* i (- (* -1 (* i (+ (* -1 (/ (pow y 2) z)) (/ (pow y 2) z)))) (* -1 y))))
(+.f64 z (*.f64 i (+.f64 (*.f64 i #s(literal 0 binary64)) y)))
(+ z (* i (- (* i (- (* -1 (/ (* i (* y (+ (* -1 (/ (pow y 2) z)) (/ (pow y 2) z)))) z)) (+ (* -1 (/ (pow y 2) z)) (/ (pow y 2) z)))) (* -1 y))))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (+.f64 (/.f64 (*.f64 i (*.f64 y #s(literal 0 binary64))) (-.f64 #s(literal 0 binary64) z)) #s(literal 0 binary64))) y)))
(* i y)
(*.f64 y i)
(* i (+ y (/ z i)))
(*.f64 i (+.f64 y (/.f64 z i)))
(* i (- (+ y (* -1 (/ (+ (* -1 (/ (pow z 2) y)) (/ (pow z 2) y)) (pow i 2)))) (* -1 (/ z i))))
(*.f64 i (+.f64 y (+.f64 (/.f64 #s(literal 0 binary64) (*.f64 i i)) (/.f64 z i))))
(* i (- (+ y (* -1 (/ (* z (+ (* -1 (/ (pow z 2) y)) (/ (pow z 2) y))) (* (pow i 3) y)))) (+ (* -1 (/ z i)) (+ (* -1 (/ (pow z 2) (* (pow i 2) y))) (/ (pow z 2) (* (pow i 2) y))))))
(*.f64 i (+.f64 (-.f64 y (/.f64 (*.f64 z #s(literal 0 binary64)) (*.f64 y (*.f64 i (*.f64 i i))))) (/.f64 z i)))
(* i y)
(*.f64 y i)
(* -1 (* i (+ (* -1 y) (* -1 (/ z i)))))
(-.f64 #s(literal 0 binary64) (*.f64 i (-.f64 (/.f64 z (-.f64 #s(literal 0 binary64) i)) y)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (- (+ (* -1 (/ (pow z 2) (* i y))) (/ (pow z 2) (* i y))) (* -1 z)) i)))))
(-.f64 #s(literal 0 binary64) (*.f64 i (-.f64 (/.f64 z (-.f64 #s(literal 0 binary64) i)) y)))
(* -1 (* i (+ (* -1 y) (* -1 (/ (- (* -1 (/ (- (* -1 (/ (* z (+ (* -1 (/ (pow z 2) y)) (/ (pow z 2) y))) (* i y))) (+ (* -1 (/ (pow z 2) y)) (/ (pow z 2) y))) i)) (* -1 z)) i)))))
(*.f64 (-.f64 #s(literal 0 binary64) i) (-.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 (+.f64 (/.f64 (+.f64 (/.f64 (*.f64 z #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 y i))) #s(literal 0 binary64)) (-.f64 #s(literal 0 binary64) i)) z) i)))
(/ 1 (* i y))
(/.f64 #s(literal 1 binary64) (*.f64 y i))
(+ (* -1 (/ z (* (pow i 2) (pow y 2)))) (/ 1 (* i y)))
(-.f64 (/.f64 #s(literal 1 binary64) (*.f64 y i)) (/.f64 (/.f64 z (*.f64 i i)) (*.f64 y y)))
(+ (* z (- (/ z (* (pow i 3) (pow y 3))) (/ 1 (* (pow i 2) (pow y 2))))) (/ 1 (* i y)))
(+.f64 (/.f64 #s(literal 1 binary64) (*.f64 y i)) (*.f64 z (+.f64 (/.f64 (/.f64 z (*.f64 i (*.f64 i i))) (*.f64 y (*.f64 y y))) (/.f64 #s(literal -1 binary64) (*.f64 (*.f64 y i) (*.f64 y i))))))
(+ (* z (- (* z (+ (* -1 (/ z (* (pow i 4) (pow y 4)))) (/ 1 (* (pow i 3) (pow y 3))))) (/ 1 (* (pow i 2) (pow y 2))))) (/ 1 (* i y)))
(+.f64 (/.f64 #s(literal 1 binary64) (*.f64 y i)) (*.f64 z (+.f64 (*.f64 z (-.f64 (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 i (*.f64 i i))) (*.f64 y (*.f64 y y))) (/.f64 (/.f64 z (pow.f64 i #s(literal 4 binary64))) (pow.f64 y #s(literal 4 binary64))))) (/.f64 #s(literal -1 binary64) (*.f64 (*.f64 y i) (*.f64 y i))))))
(/ 1 z)
(/.f64 #s(literal 1 binary64) z)
(/ (+ 1 (* -1 (/ (* i y) z))) z)
(/.f64 (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)) z)
(/ (+ 1 (+ (* -1 (/ (* i y) z)) (/ (* (pow i 2) (pow y 2)) (pow z 2)))) z)
(/.f64 (+.f64 (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z z))) z)
(/ (+ 1 (+ (* -1 (/ (* i y) z)) (+ (* -1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) (/ (* (pow i 2) (pow y 2)) (pow z 2))))) z)
(/.f64 (+.f64 (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)) (-.f64 (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z z)) (/.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z))))) z)
(/ 1 z)
(/.f64 #s(literal 1 binary64) z)
(* -1 (/ (- (/ (* i y) z) 1) z))
(/.f64 (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)) z)
(* -1 (/ (- (* -1 (/ (+ (* -1 (* i y)) (/ (* (pow i 2) (pow y 2)) z)) z)) 1) z))
(/.f64 (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 y i) (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z))) z)) z)
(* -1 (/ (- (* -1 (/ (+ (* -1 (* i y)) (* -1 (/ (+ (* -1 (* (pow i 2) (pow y 2))) (/ (* (pow i 3) (pow y 3)) z)) z))) z)) 1) z))
(/.f64 (+.f64 (/.f64 (-.f64 (-.f64 #s(literal 0 binary64) (*.f64 y i)) (/.f64 (-.f64 (/.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) z) (*.f64 (*.f64 y i) (*.f64 y i))) z)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(/ 1 z)
(/.f64 #s(literal 1 binary64) z)
(+ (* -1 (/ (* i y) (pow z 2))) (/ 1 z))
(-.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 (*.f64 y i) (*.f64 z z)))
(+ (* y (+ (* -1 (/ i (pow z 2))) (/ (* (pow i 2) y) (pow z 3)))) (/ 1 z))
(+.f64 (/.f64 #s(literal 1 binary64) z) (*.f64 y (-.f64 (/.f64 (*.f64 y (*.f64 i i)) (*.f64 z (*.f64 z z))) (/.f64 i (*.f64 z z)))))
(+ (* y (+ (* -1 (/ i (pow z 2))) (* y (+ (* -1 (/ (* (pow i 3) y) (pow z 4))) (/ (pow i 2) (pow z 3)))))) (/ 1 z))
(+.f64 (/.f64 #s(literal 1 binary64) z) (*.f64 y (-.f64 (*.f64 y (-.f64 (/.f64 (*.f64 i i) (*.f64 z (*.f64 z z))) (/.f64 (*.f64 y (*.f64 i (*.f64 i i))) (pow.f64 z #s(literal 4 binary64))))) (/.f64 i (*.f64 z z)))))
(/ 1 (* i y))
(/.f64 #s(literal 1 binary64) (*.f64 y i))
(/ (+ (* -1 (/ z (* (pow i 2) y))) (/ 1 i)) y)
(/.f64 (-.f64 (/.f64 #s(literal 1 binary64) i) (/.f64 (/.f64 z (*.f64 i i)) y)) y)
(/ (+ (* -1 (/ z (* (pow i 2) y))) (+ (/ 1 i) (/ (pow z 2) (* (pow i 3) (pow y 2))))) y)
(/.f64 (+.f64 (-.f64 (/.f64 #s(literal 1 binary64) i) (/.f64 (/.f64 z (*.f64 i i)) y)) (/.f64 (/.f64 (*.f64 z z) (*.f64 i (*.f64 i i))) (*.f64 y y))) y)
(/ (+ (* -1 (/ z (* (pow i 2) y))) (+ (* -1 (/ (pow z 3) (* (pow i 4) (pow y 3)))) (+ (/ 1 i) (/ (pow z 2) (* (pow i 3) (pow y 2)))))) y)
(/.f64 (-.f64 (-.f64 (+.f64 (/.f64 #s(literal 1 binary64) i) (/.f64 (/.f64 (*.f64 z z) (*.f64 i (*.f64 i i))) (*.f64 y y))) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y (*.f64 y y)) (pow.f64 i #s(literal 4 binary64))))) (/.f64 (/.f64 z (*.f64 i i)) y)) y)
(/ 1 (* i y))
(/.f64 #s(literal 1 binary64) (*.f64 y i))
(* -1 (/ (- (/ z (* (pow i 2) y)) (/ 1 i)) y))
(/.f64 (+.f64 (/.f64 (/.f64 z (*.f64 i i)) y) (/.f64 #s(literal -1 binary64) i)) (-.f64 #s(literal 0 binary64) y))
(* -1 (/ (- (* -1 (/ (+ (* -1 (/ z (pow i 2))) (/ (pow z 2) (* (pow i 3) y))) y)) (/ 1 i)) y))
(/.f64 (+.f64 (/.f64 (-.f64 (/.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 i i)))) (/.f64 z (*.f64 i i))) (-.f64 #s(literal 0 binary64) y)) (/.f64 #s(literal -1 binary64) i)) (-.f64 #s(literal 0 binary64) y))
(* -1 (/ (- (* -1 (/ (+ (* -1 (/ z (pow i 2))) (* -1 (/ (+ (* -1 (/ (pow z 2) (pow i 3))) (/ (pow z 3) (* (pow i 4) y))) y))) y)) (/ 1 i)) y))
(/.f64 (+.f64 (/.f64 (-.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (*.f64 i i))) (/.f64 (-.f64 (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (pow.f64 i #s(literal 4 binary64)))) (/.f64 (*.f64 z z) (*.f64 i (*.f64 i i)))) y)) (-.f64 #s(literal 0 binary64) y)) (/.f64 #s(literal -1 binary64) i)) (-.f64 #s(literal 0 binary64) y))
(/ 1 z)
(/.f64 #s(literal 1 binary64) z)
(+ (* -1 (/ (* i y) (pow z 2))) (/ 1 z))
(-.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 (*.f64 y i) (*.f64 z z)))
(+ (* i (+ (* -1 (/ y (pow z 2))) (/ (* i (pow y 2)) (pow z 3)))) (/ 1 z))
(+.f64 (/.f64 #s(literal 1 binary64) z) (*.f64 i (-.f64 (/.f64 (*.f64 i (*.f64 y y)) (*.f64 z (*.f64 z z))) (/.f64 y (*.f64 z z)))))
(+ (* i (+ (* -1 (/ y (pow z 2))) (* i (+ (* -1 (/ (* i (pow y 3)) (pow z 4))) (/ (pow y 2) (pow z 3)))))) (/ 1 z))
(+.f64 (/.f64 #s(literal 1 binary64) z) (*.f64 i (-.f64 (*.f64 i (-.f64 (/.f64 (*.f64 y y) (*.f64 z (*.f64 z z))) (/.f64 (*.f64 i (*.f64 y (*.f64 y y))) (pow.f64 z #s(literal 4 binary64))))) (/.f64 y (*.f64 z z)))))
(/ 1 (* i y))
(/.f64 #s(literal 1 binary64) (*.f64 y i))
(/ (+ (* -1 (/ z (* i (pow y 2)))) (/ 1 y)) i)
(/.f64 (-.f64 (/.f64 #s(literal 1 binary64) y) (/.f64 (/.f64 z i) (*.f64 y y))) i)
(/ (+ (* -1 (/ z (* i (pow y 2)))) (+ (/ 1 y) (/ (pow z 2) (* (pow i 2) (pow y 3))))) i)
(/.f64 (+.f64 (-.f64 (/.f64 #s(literal 1 binary64) y) (/.f64 (/.f64 z i) (*.f64 y y))) (/.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y (*.f64 y y)))) i)
(/ (+ (* -1 (/ z (* i (pow y 2)))) (+ (* -1 (/ (pow z 3) (* (pow i 3) (pow y 4)))) (+ (/ 1 y) (/ (pow z 2) (* (pow i 2) (pow y 3)))))) i)
(/.f64 (-.f64 (-.f64 (+.f64 (/.f64 #s(literal 1 binary64) y) (/.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y (*.f64 y y)))) (*.f64 (/.f64 (*.f64 z z) (*.f64 i (*.f64 i i))) (/.f64 z (pow.f64 y #s(literal 4 binary64))))) (/.f64 (/.f64 z i) (*.f64 y y))) i)
(/ 1 (* i y))
(/.f64 #s(literal 1 binary64) (*.f64 y i))
(* -1 (/ (- (/ z (* i (pow y 2))) (/ 1 y)) i))
(/.f64 (+.f64 (/.f64 (/.f64 z i) (*.f64 y y)) (/.f64 #s(literal -1 binary64) y)) (-.f64 #s(literal 0 binary64) i))
(* -1 (/ (- (* -1 (/ (+ (* -1 (/ z (pow y 2))) (/ (pow z 2) (* i (pow y 3)))) i)) (/ 1 y)) i))
(/.f64 (+.f64 (/.f64 (-.f64 (/.f64 (*.f64 z z) (*.f64 i (*.f64 y (*.f64 y y)))) (/.f64 z (*.f64 y y))) (-.f64 #s(literal 0 binary64) i)) (/.f64 #s(literal -1 binary64) y)) (-.f64 #s(literal 0 binary64) i))
(* -1 (/ (- (* -1 (/ (+ (* -1 (/ z (pow y 2))) (* -1 (/ (+ (* -1 (/ (pow z 2) (pow y 3))) (/ (pow z 3) (* i (pow y 4)))) i))) i)) (/ 1 y)) i))
(/.f64 (+.f64 (/.f64 (-.f64 (-.f64 #s(literal 0 binary64) (/.f64 z (*.f64 y y))) (/.f64 (-.f64 (/.f64 (*.f64 z (*.f64 z z)) (*.f64 i (pow.f64 y #s(literal 4 binary64)))) (/.f64 (*.f64 z z) (*.f64 y (*.f64 y y)))) i)) (-.f64 #s(literal 0 binary64) i)) (/.f64 #s(literal -1 binary64) y)) (-.f64 #s(literal 0 binary64) i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(+ (* -1 (* i (* y z))) (* (pow i 2) (pow y 2)))
(-.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 (*.f64 y i) z))
(+ (* z (+ z (* -1 (* i y)))) (* (pow i 2) (pow y 2)))
(+.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z (-.f64 z (*.f64 y i))))
(+ (* z (+ z (* -1 (* i y)))) (* (pow i 2) (pow y 2)))
(+.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z (-.f64 z (*.f64 y i))))
(pow z 2)
(*.f64 z z)
(* (pow z 2) (+ 1 (* -1 (/ (* i y) z))))
(*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(* (pow z 2) (+ 1 (+ (* -1 (/ (* i y) z)) (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(*.f64 (*.f64 z z) (+.f64 (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z z))))
(* (pow z 2) (+ 1 (+ (* -1 (/ (* i y) z)) (/ (* (pow i 2) (pow y 2)) (pow z 2)))))
(*.f64 (*.f64 z z) (+.f64 (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 z z))))
(pow z 2)
(*.f64 z z)
(* (pow z 2) (+ 1 (* -1 (/ (* i y) z))))
(*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(* (pow z 2) (+ 1 (* -1 (/ (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y)) z))))
(*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 y i) (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z))) z)))
(* (pow z 2) (+ 1 (* -1 (/ (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y)) z))))
(*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 y i) (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z))) z)))
(pow z 2)
(*.f64 z z)
(+ (* -1 (* i (* y z))) (pow z 2))
(*.f64 z (-.f64 z (*.f64 y i)))
(+ (* y (+ (* -1 (* i z)) (* (pow i 2) y))) (pow z 2))
(+.f64 (*.f64 z z) (*.f64 y (-.f64 (*.f64 y (*.f64 i i)) (*.f64 z i))))
(+ (* y (+ (* -1 (* i z)) (* (pow i 2) y))) (pow z 2))
(+.f64 (*.f64 z z) (*.f64 y (-.f64 (*.f64 y (*.f64 i i)) (*.f64 z i))))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(*.f64 (*.f64 y y) (-.f64 (*.f64 i i) (/.f64 (*.f64 z i) y)))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (+ (/ (pow z 2) (pow y 2)) (pow i 2))))
(*.f64 (*.f64 y y) (-.f64 (+.f64 (*.f64 i i) (/.f64 (*.f64 z z) (*.f64 y y))) (/.f64 (*.f64 z i) y)))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (+ (/ (pow z 2) (pow y 2)) (pow i 2))))
(*.f64 (*.f64 y y) (-.f64 (+.f64 (*.f64 i i) (/.f64 (*.f64 z z) (*.f64 y y))) (/.f64 (*.f64 z i) y)))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(*.f64 (*.f64 y y) (-.f64 (*.f64 i i) (/.f64 (*.f64 z i) y)))
(* (pow y 2) (+ (* -1 (/ (+ (* -1 (/ (pow z 2) y)) (* i z)) y)) (pow i 2)))
(*.f64 (*.f64 y y) (-.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 z i) (/.f64 (*.f64 z z) y)) y)))
(* (pow y 2) (+ (* -1 (/ (+ (* -1 (/ (pow z 2) y)) (* i z)) y)) (pow i 2)))
(*.f64 (*.f64 y y) (-.f64 (*.f64 i i) (/.f64 (-.f64 (*.f64 z i) (/.f64 (*.f64 z z) y)) y)))
(pow z 2)
(*.f64 z z)
(+ (* -1 (* i (* y z))) (pow z 2))
(*.f64 z (-.f64 z (*.f64 y i)))
(+ (* i (+ (* -1 (* y z)) (* i (pow y 2)))) (pow z 2))
(+.f64 (*.f64 z z) (*.f64 i (-.f64 (*.f64 i (*.f64 y y)) (*.f64 z y))))
(+ (* i (+ (* -1 (* y z)) (* i (pow y 2)))) (pow z 2))
(+.f64 (*.f64 z z) (*.f64 i (-.f64 (*.f64 i (*.f64 y y)) (*.f64 z y))))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (*.f64 y y) (/.f64 (*.f64 z y) i)))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (+ (/ (pow z 2) (pow i 2)) (pow y 2))))
(*.f64 (*.f64 i i) (+.f64 (-.f64 (*.f64 y y) (/.f64 (*.f64 z y) i)) (/.f64 (*.f64 z z) (*.f64 i i))))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (+ (/ (pow z 2) (pow i 2)) (pow y 2))))
(*.f64 (*.f64 i i) (+.f64 (-.f64 (*.f64 y y) (/.f64 (*.f64 z y) i)) (/.f64 (*.f64 z z) (*.f64 i i))))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (*.f64 y y) (/.f64 (*.f64 z y) i)))
(* (pow i 2) (+ (* -1 (/ (+ (* -1 (/ (pow z 2) i)) (* y z)) i)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (*.f64 y y) (/.f64 (-.f64 (*.f64 z y) (/.f64 (*.f64 z z) i)) i)))
(* (pow i 2) (+ (* -1 (/ (+ (* -1 (/ (pow z 2) i)) (* y z)) i)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (*.f64 y y) (/.f64 (-.f64 (*.f64 z y) (/.f64 (*.f64 z z) i)) i)))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (* -1 (* (log (/ 1 c)) (- b 1/2)))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ z (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))))
(+ a (+ z (* -1/2 (log c))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64))))
(+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (+ (* -1/2 (log c)) (* b (log c)))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (/.f64 z b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (/.f64 z b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (/ z b)))))
(*.f64 b (+.f64 (log.f64 c) (+.f64 (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b) (+.f64 (/.f64 a b) (/.f64 z b)))))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 c)) (/.f64 (+.f64 a (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 c)) (/.f64 (+.f64 a (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ z (* -1/2 (log c)))) b)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (log.f64 c)) (/.f64 (+.f64 a (+.f64 z (*.f64 (log.f64 c) #s(literal -1/2 binary64)))) b)) (neg.f64 b))
(+ z (* (log c) (- b 1/2)))
(+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
a
(* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(*.f64 a (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 z a)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
(* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(*.f64 a (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 z a)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
(* a (+ 1 (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(*.f64 a (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 z a)) (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)))
a
(* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ z (* (log c) (- b 1/2))) a)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(+ a (* (log c) (- b 1/2)))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+ a (+ z (* (log c) (- b 1/2))))
(+.f64 a (+.f64 z (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
z
(* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))
(*.f64 z (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))))
(* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))
(*.f64 z (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))))
(* z (+ 1 (+ (/ a z) (/ (* (log c) (- b 1/2)) z))))
(*.f64 z (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))))
z
(* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))
(*.f64 (-.f64 #s(literal 0 binary64) z) (+.f64 (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)))
(* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))
(*.f64 (-.f64 #s(literal 0 binary64) z) (+.f64 (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)))
(* -1 (* z (- (* -1 (/ (+ a (* (log c) (- b 1/2))) z)) 1)))
(*.f64 (-.f64 #s(literal 0 binary64) z) (+.f64 (/.f64 (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (log c) (- b 1/2))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (+.f64 b #s(literal -1/2 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))))
(* -1/2 (log c))
(*.f64 (log.f64 c) #s(literal -1/2 binary64))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 b (+.f64 (log.f64 c) (/.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) b)))
(* b (log c))
(*.f64 (log.f64 c) b)
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 c)) b) (log.f64 c)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 c)) b) (log.f64 c)) (neg.f64 b))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 (-.f64 (/.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 c)) b) (log.f64 c)) (neg.f64 b))
(log c)
(log.f64 c)
(log c)
(log.f64 c)
(log c)
(log.f64 c)
(log c)
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
-1/2
#s(literal -1/2 binary64)
(- b 1/2)
(+.f64 b #s(literal -1/2 binary64))
(- b 1/2)
(+.f64 b #s(literal -1/2 binary64))
(- b 1/2)
(+.f64 b #s(literal -1/2 binary64))
b
(* b (- 1 (* 1/2 (/ 1 b))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) b)))
(* b (- 1 (* 1/2 (/ 1 b))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) b)))
(* b (- 1 (* 1/2 (/ 1 b))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) b)))
b
(* -1 (* b (- (* 1/2 (/ 1 b)) 1)))
(*.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) b) #s(literal -1 binary64)) (neg.f64 b))
(* -1 (* b (- (* 1/2 (/ 1 b)) 1)))
(*.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) b) #s(literal -1 binary64)) (neg.f64 b))
(* -1 (* b (- (* 1/2 (/ 1 b)) 1)))
(*.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) b) #s(literal -1 binary64)) (neg.f64 b))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* x (log y))
(*.f64 x (log.f64 y))
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) y)) (neg.f64 x))
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) y)) (neg.f64 x))
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) y)) (neg.f64 x))
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 (/.f64 #s(literal 1 binary64) y)) (neg.f64 x))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 x (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))))
(pow z 3)
(*.f64 z (*.f64 z z))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))
(* (pow i 3) (pow y 3))
(*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y)))
(* (pow y 3) (+ (/ (pow z 3) (pow y 3)) (pow i 3)))
(*.f64 (*.f64 y (*.f64 y y)) (+.f64 (*.f64 i (*.f64 i i)) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 y y)))))
(* (pow y 3) (+ (/ (pow z 3) (pow y 3)) (pow i 3)))
(*.f64 (*.f64 y (*.f64 y y)) (+.f64 (*.f64 i (*.f64 i i)) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 y y)))))
(* (pow y 3) (+ (/ (pow z 3) (pow y 3)) (pow i 3)))
(*.f64 (*.f64 y (*.f64 y y)) (+.f64 (*.f64 i (*.f64 i i)) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 y y)))))
(* (pow i 3) (pow y 3))
(*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y)))
(* -1 (* (pow y 3) (+ (* -1 (/ (pow z 3) (pow y 3))) (* -1 (pow i 3)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i i))) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 y y)))) (-.f64 #s(literal 0 binary64) (*.f64 y (*.f64 y y))))
(* -1 (* (pow y 3) (+ (* -1 (/ (pow z 3) (pow y 3))) (* -1 (pow i 3)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i i))) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 y y)))) (-.f64 #s(literal 0 binary64) (*.f64 y (*.f64 y y))))
(* -1 (* (pow y 3) (+ (* -1 (/ (pow z 3) (pow y 3))) (* -1 (pow i 3)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i i))) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 y y)))) (-.f64 #s(literal 0 binary64) (*.f64 y (*.f64 y y))))
(pow z 3)
(*.f64 z (*.f64 z z))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))
(* (pow i 3) (pow y 3))
(*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y)))
(* (pow i 3) (+ (/ (pow z 3) (pow i 3)) (pow y 3)))
(*.f64 (*.f64 i (*.f64 i i)) (+.f64 (*.f64 y (*.f64 y y)) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 i (*.f64 i i)))))
(* (pow i 3) (+ (/ (pow z 3) (pow i 3)) (pow y 3)))
(*.f64 (*.f64 i (*.f64 i i)) (+.f64 (*.f64 y (*.f64 y y)) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 i (*.f64 i i)))))
(* (pow i 3) (+ (/ (pow z 3) (pow i 3)) (pow y 3)))
(*.f64 (*.f64 i (*.f64 i i)) (+.f64 (*.f64 y (*.f64 y y)) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 i (*.f64 i i)))))
(* (pow i 3) (pow y 3))
(*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y)))
(* -1 (* (pow i 3) (+ (* -1 (/ (pow z 3) (pow i 3))) (* -1 (pow y 3)))))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i i))) (-.f64 (/.f64 (*.f64 z (*.f64 z z)) (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i i)))) (*.f64 y (*.f64 y y))))
(* -1 (* (pow i 3) (+ (* -1 (/ (pow z 3) (pow i 3))) (* -1 (pow y 3)))))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i i))) (-.f64 (/.f64 (*.f64 z (*.f64 z z)) (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i i)))) (*.f64 y (*.f64 y y))))
(* -1 (* (pow i 3) (+ (* -1 (/ (pow z 3) (pow i 3))) (* -1 (pow y 3)))))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i i))) (-.f64 (/.f64 (*.f64 z (*.f64 z z)) (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i i)))) (*.f64 y (*.f64 y y))))
(* (pow i 3) (pow y 3))
(*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y)))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))
(+ (* (pow i 3) (pow y 3)) (pow z 3))
(+.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))
(pow z 3)
(*.f64 z (*.f64 z z))
(* (pow z 3) (+ 1 (/ (* (pow i 3) (pow y 3)) (pow z 3))))
(*.f64 (*.f64 z (*.f64 z z)) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))))
(* (pow z 3) (+ 1 (/ (* (pow i 3) (pow y 3)) (pow z 3))))
(*.f64 (*.f64 z (*.f64 z z)) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))))
(* (pow z 3) (+ 1 (/ (* (pow i 3) (pow y 3)) (pow z 3))))
(*.f64 (*.f64 z (*.f64 z z)) (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))))
(pow z 3)
(*.f64 z (*.f64 z z))
(* -1 (* (pow z 3) (- (* -1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))) #s(literal -1 binary64)) (*.f64 #s(literal -1 binary64) (*.f64 z (*.f64 z z))))
(* -1 (* (pow z 3) (- (* -1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))) #s(literal -1 binary64)) (*.f64 #s(literal -1 binary64) (*.f64 z (*.f64 z z))))
(* -1 (* (pow z 3) (- (* -1 (/ (* (pow i 3) (pow y 3)) (pow z 3))) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (*.f64 (*.f64 i (*.f64 i i)) (*.f64 y (*.f64 y y))) (*.f64 z (*.f64 z z)))) #s(literal -1 binary64)) (*.f64 #s(literal -1 binary64) (*.f64 z (*.f64 z z))))
(* -1 (* i (* y z)))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 y i)) z)
(* y (+ (* -1 (* i z)) (* (pow i 2) y)))
(*.f64 y (-.f64 (*.f64 y (*.f64 i i)) (*.f64 z i)))
(* y (+ (* -1 (* i z)) (* (pow i 2) y)))
(*.f64 y (-.f64 (*.f64 y (*.f64 i i)) (*.f64 z i)))
(* y (+ (* -1 (* i z)) (* (pow i 2) y)))
(*.f64 y (-.f64 (*.f64 y (*.f64 i i)) (*.f64 z i)))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(*.f64 (*.f64 y y) (-.f64 (*.f64 i i) (/.f64 (*.f64 z i) y)))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(*.f64 (*.f64 y y) (-.f64 (*.f64 i i) (/.f64 (*.f64 z i) y)))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(*.f64 (*.f64 y y) (-.f64 (*.f64 i i) (/.f64 (*.f64 z i) y)))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(*.f64 (*.f64 y y) (-.f64 (*.f64 i i) (/.f64 (*.f64 z i) y)))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(*.f64 (*.f64 y y) (-.f64 (*.f64 i i) (/.f64 (*.f64 z i) y)))
(* (pow y 2) (+ (* -1 (/ (* i z) y)) (pow i 2)))
(*.f64 (*.f64 y y) (-.f64 (*.f64 i i) (/.f64 (*.f64 z i) y)))
(* -1 (* i (* y z)))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 y i)) z)
(* i (+ (* -1 (* y z)) (* i (pow y 2))))
(*.f64 i (-.f64 (*.f64 i (*.f64 y y)) (*.f64 z y)))
(* i (+ (* -1 (* y z)) (* i (pow y 2))))
(*.f64 i (-.f64 (*.f64 i (*.f64 y y)) (*.f64 z y)))
(* i (+ (* -1 (* y z)) (* i (pow y 2))))
(*.f64 i (-.f64 (*.f64 i (*.f64 y y)) (*.f64 z y)))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (*.f64 y y) (/.f64 (*.f64 z y) i)))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (*.f64 y y) (/.f64 (*.f64 z y) i)))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (*.f64 y y) (/.f64 (*.f64 z y) i)))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (*.f64 y y) (/.f64 (*.f64 z y) i)))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (*.f64 y y) (/.f64 (*.f64 z y) i)))
(* (pow i 2) (+ (* -1 (/ (* y z) i)) (pow y 2)))
(*.f64 (*.f64 i i) (-.f64 (*.f64 y y) (/.f64 (*.f64 z y) i)))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(+ (* -1 (* i (* y z))) (* (pow i 2) (pow y 2)))
(-.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 (*.f64 y i) z))
(+ (* -1 (* i (* y z))) (* (pow i 2) (pow y 2)))
(-.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 (*.f64 y i) z))
(+ (* -1 (* i (* y z))) (* (pow i 2) (pow y 2)))
(-.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (*.f64 (*.f64 y i) z))
(* -1 (* i (* y z)))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 y i)) z)
(* z (+ (* -1 (* i y)) (/ (* (pow i 2) (pow y 2)) z)))
(*.f64 z (-.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)))
(* z (+ (* -1 (* i y)) (/ (* (pow i 2) (pow y 2)) z)))
(*.f64 z (-.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)))
(* z (+ (* -1 (* i y)) (/ (* (pow i 2) (pow y 2)) z)))
(*.f64 z (-.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)))
(* -1 (* i (* y z)))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 y i)) z)
(* -1 (* z (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y))))
(*.f64 (-.f64 #s(literal 0 binary64) z) (-.f64 (*.f64 y i) (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z))))
(* -1 (* z (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y))))
(*.f64 (-.f64 #s(literal 0 binary64) z) (-.f64 (*.f64 y i) (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z))))
(* -1 (* z (+ (* -1 (/ (* (pow i 2) (pow y 2)) z)) (* i y))))
(*.f64 (-.f64 #s(literal 0 binary64) z) (-.f64 (*.f64 y i) (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z))))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
(* (pow i 2) (pow y 2))
(*.f64 (*.f64 y i) (*.f64 y i))
z
(+ a z)
(+.f64 z a)
(+ a z)
(+.f64 z a)
(+ a z)
(+.f64 z a)
a
(* a (+ 1 (/ z a)))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 z a)))
(* a (+ 1 (/ z a)))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 z a)))
(* a (+ 1 (/ z a)))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 z a)))
a
(* -1 (* a (- (* -1 (/ z a)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 z a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ z a)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 z a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ z a)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 z a)) #s(literal -1 binary64)) (neg.f64 a))
a
(+ a z)
(+.f64 z a)
(+ a z)
(+.f64 z a)
(+ a z)
(+.f64 z a)
z
(* z (+ 1 (/ a z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 a z)))
(* z (+ 1 (/ a z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 a z)))
(* z (+ 1 (/ a z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 a z)))
z
(* -1 (* z (- (* -1 (/ a z)) 1)))
(*.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) #s(literal -1 binary64)))
(* -1 (* z (- (* -1 (/ a z)) 1)))
(*.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) #s(literal -1 binary64)))
(* -1 (* z (- (* -1 (/ a z)) 1)))
(*.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) #s(literal -1 binary64)))

eval199.0ms (1.5%)

Compiler

Compiled 55512 to 3624 computations (93.5% saved)

prune291.0ms (2.2%)

Pruning

47 alts after pruning (42 fresh and 5 done)

PrunedKeptTotal
New1584211605
Fresh102131
Picked415
Done044
Total1598471645
Accuracy
100.0%
Counts
1645 → 47
Alt Table
Click to see full alt table
StatusAccuracyProgram
3.2%
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
3.0%
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
1.8%
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
3.0%
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
3.1%
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
9.4%
(/.f64 (*.f64 z z) z)
4.7%
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
8.7%
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
7.3%
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
2.6%
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
3.7%
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
2.8%
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
23.6%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z))
50.6%
(+.f64 (/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 y i))
43.8%
(+.f64 (/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) a) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) a)) (*.f64 y i))
69.2%
(+.f64 (+.f64 (+.f64 (*.f64 a (/.f64 (*.f64 x (log.f64 y)) a)) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
42.4%
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (/.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 b #s(literal 1/2 binary64)))) (*.f64 y i))
36.8%
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
57.1%
(+.f64 (*.f64 (log.f64 c) b) (+.f64 a z))
30.9%
(+.f64 (*.f64 (log.f64 c) b) (*.f64 x (log.f64 y)))
52.2%
(+.f64 (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 a #s(literal 1 binary64)))
33.1%
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
41.9%
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
69.2%
(+.f64 (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) a)) (+.f64 #s(literal 1 binary64) (/.f64 z a)))) (*.f64 y i))
29.8%
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
✓47.2%
(+.f64 z (*.f64 y i))
40.0%
(+.f64 z (*.f64 x (log.f64 y)))
26.5%
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
59.5%
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
45.6%
(+.f64 a (*.f64 y i))
38.4%
(+.f64 a (*.f64 x (log.f64 y)))
3.5%
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
23.3%
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
24.2%
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
2.2%
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
✓14.6%
(*.f64 (log.f64 c) b)
50.7%
(*.f64 z (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))))
42.7%
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
15.5%
(*.f64 y (/.f64 a y))
39.3%
(*.f64 y (+.f64 (/.f64 a y) i))
37.7%
(*.f64 y (+.f64 i (/.f64 z y)))
67.8%
(*.f64 y (+.f64 i (+.f64 (*.f64 (log.f64 y) (/.f64 x y)) (+.f64 (+.f64 (/.f64 z y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) (+.f64 (/.f64 a y) (/.f64 t y))))))
33.7%
(*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
✓25.8%
(*.f64 y i)
18.4%
(*.f64 x (log.f64 y))
✓23.7%
z
✓21.8%
a
Compiler

Compiled 2462 to 1019 computations (58.6% saved)

regimes330.0ms (2.5%)

Counts
76 → 1
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
(+.f64 a (*.f64 y i))
(+.f64 z (*.f64 y i))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z))
(/.f64 (*.f64 z z) z)
(*.f64 i (+.f64 y (/.f64 z i)))
(*.f64 y (+.f64 i (/.f64 z y)))
(*.f64 y (+.f64 (/.f64 a y) i))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 (*.f64 i i) y))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (*.f64 y i) y) i)) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z (*.f64 y i)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 c) b)
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (+.f64 a z))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(*.f64 i (+.f64 y (+.f64 (/.f64 a i) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)))))
(*.f64 y (+.f64 (/.f64 a y) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) i)))
(*.f64 z (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))))
(+.f64 (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 a #s(literal 1 binary64)))
(+.f64 (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) a)) (+.f64 #s(literal 1 binary64) (/.f64 z a)))) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (/.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 b #s(literal 1/2 binary64)))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 (*.f64 a (/.f64 (*.f64 x (log.f64 y)) a)) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(*.f64 i (+.f64 y (/.f64 (+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) i)))
(+.f64 (+.f64 (+.f64 (*.f64 a (/.f64 (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)) a)) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (/.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 b #s(literal 1/2 binary64)))) (*.f64 y i))
(*.f64 y (+.f64 i (+.f64 (*.f64 (log.f64 y) (/.f64 x y)) (+.f64 (+.f64 (/.f64 z y) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))) (+.f64 (/.f64 a y) (/.f64 t y))))))
(+.f64 (*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (*.f64 x (/.f64 (log.f64 y) a)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) a))) (+.f64 (/.f64 t a) (/.f64 z a))))) (*.f64 y i))
(+.f64 (/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) a) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) a)) (*.f64 y i))
(+.f64 (/.f64 (+.f64 (*.f64 (-.f64 (pow.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z))))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) #s(literal 1 binary64))) (*.f64 (-.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (log.f64 c)) a) (/.f64 a (*.f64 a (+.f64 (*.f64 x (log.f64 y)) (+.f64 t z)))))) (*.f64 y i))
Outputs
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Calls

12 calls:

53.0ms
y
32.0ms
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
27.0ms
b
25.0ms
i
25.0ms
(log.f64 c)
Results
AccuracySegmentsBranch
99.9%1x
99.9%1y
99.9%1z
99.9%1t
99.9%1a
99.9%1b
99.9%1c
99.9%1i
99.9%1(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
99.9%1(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
99.9%1(-.f64 b #s(literal 1/2 binary64))
99.9%1(log.f64 c)
Compiler

Compiled 136 to 115 computations (15.4% saved)

regimes242.0ms (1.9%)

Counts
68 → 2
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
(+.f64 a (*.f64 y i))
(+.f64 z (*.f64 y i))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z))
(/.f64 (*.f64 z z) z)
(*.f64 i (+.f64 y (/.f64 z i)))
(*.f64 y (+.f64 i (/.f64 z y)))
(*.f64 y (+.f64 (/.f64 a y) i))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 (*.f64 i i) y))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (*.f64 y i) y) i)) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z (*.f64 y i)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 c) b)
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (+.f64 a z))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(*.f64 i (+.f64 y (+.f64 (/.f64 a i) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)))))
(*.f64 y (+.f64 (/.f64 a y) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) i)))
(*.f64 z (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))))
(+.f64 (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 a #s(literal 1 binary64)))
(+.f64 (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) a)) (+.f64 #s(literal 1 binary64) (/.f64 z a)))) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (/.f64 (*.f64 (+.f64 (*.f64 b b) #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 b #s(literal 1/2 binary64)))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 (*.f64 a (/.f64 (*.f64 x (log.f64 y)) a)) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Outputs
(+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y)))
(+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Calls

11 calls:

28.0ms
b
21.0ms
z
21.0ms
t
21.0ms
(log.f64 c)
20.0ms
i
Results
AccuracySegmentsBranch
92.8%3x
95.4%2y
91.3%3z
84.9%2t
82.5%1a
87.2%3b
82.5%1c
91.6%3i
82.5%1(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
82.5%1(-.f64 b #s(literal 1/2 binary64))
82.5%1(log.f64 c)
Compiler

Compiled 107 to 95 computations (11.2% saved)

regimes78.0ms (0.6%)

Counts
65 → 3
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
(+.f64 a (*.f64 y i))
(+.f64 z (*.f64 y i))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z))
(/.f64 (*.f64 z z) z)
(*.f64 i (+.f64 y (/.f64 z i)))
(*.f64 y (+.f64 i (/.f64 z y)))
(*.f64 y (+.f64 (/.f64 a y) i))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 (*.f64 i i) y))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (*.f64 y i) y) i)) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z (*.f64 y i)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 c) b)
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (+.f64 a z))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(*.f64 i (+.f64 y (+.f64 (/.f64 a i) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)))))
(*.f64 y (+.f64 (/.f64 a y) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) i)))
(*.f64 z (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))))
(+.f64 (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 a #s(literal 1 binary64)))
(+.f64 (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) a)) (+.f64 #s(literal 1 binary64) (/.f64 z a)))) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Outputs
(+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
Calls

2 calls:

41.0ms
x
21.0ms
y
Results
AccuracySegmentsBranch
91.8%3x
82.5%1y
Compiler

Compiled 18 to 16 computations (11.1% saved)

regimes50.0ms (0.4%)

Counts
64 → 3
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
(+.f64 a (*.f64 y i))
(+.f64 z (*.f64 y i))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z))
(/.f64 (*.f64 z z) z)
(*.f64 i (+.f64 y (/.f64 z i)))
(*.f64 y (+.f64 i (/.f64 z y)))
(*.f64 y (+.f64 (/.f64 a y) i))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 (*.f64 i i) y))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (*.f64 y i) y) i)) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z (*.f64 y i)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 c) b)
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (+.f64 a z))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(*.f64 i (+.f64 y (+.f64 (/.f64 a i) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) i)))))
(*.f64 y (+.f64 (/.f64 a y) (+.f64 (/.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) y) i)))
(*.f64 z (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) z))))
(+.f64 (*.f64 y (+.f64 i (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) y)))) (*.f64 a #s(literal 1 binary64)))
(+.f64 (*.f64 a (+.f64 (*.f64 (+.f64 b #s(literal -1/2 binary64)) (/.f64 (log.f64 c) a)) (+.f64 #s(literal 1 binary64) (/.f64 z a)))) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))
Outputs
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
(+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
Calls

2 calls:

21.0ms
i
20.0ms
x
Results
AccuracySegmentsBranch
82.5%1i
91.4%3x
Compiler

Compiled 18 to 16 computations (11.1% saved)

regimes224.0ms (1.7%)

Counts
56 → 4
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
(+.f64 a (*.f64 y i))
(+.f64 z (*.f64 y i))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z))
(/.f64 (*.f64 z z) z)
(*.f64 i (+.f64 y (/.f64 z i)))
(*.f64 y (+.f64 i (/.f64 z y)))
(*.f64 y (+.f64 (/.f64 a y) i))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 (*.f64 i i) y))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (*.f64 y i) y) i)) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z (*.f64 y i)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 c) b)
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (+.f64 a z))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Outputs
(+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (+.f64 (+.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Calls

11 calls:

37.0ms
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
21.0ms
y
19.0ms
c
19.0ms
x
18.0ms
(log.f64 c)
Results
AccuracySegmentsBranch
66.2%3c
65.5%2(-.f64 b #s(literal 1/2 binary64))
66.2%3(log.f64 c)
66.9%4(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
77.4%2a
78.1%4i
76.5%3y
73.3%2t
73.5%6b
81.9%4z
75.9%4x
Compiler

Compiled 107 to 95 computations (11.2% saved)

regimes27.0ms (0.2%)

Counts
55 → 4
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
(+.f64 a (*.f64 y i))
(+.f64 z (*.f64 y i))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z))
(/.f64 (*.f64 z z) z)
(*.f64 i (+.f64 y (/.f64 z i)))
(*.f64 y (+.f64 i (/.f64 z y)))
(*.f64 y (+.f64 (/.f64 a y) i))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 (*.f64 i i) y))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (*.f64 y i) y) i)) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z (*.f64 y i)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 c) b)
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (+.f64 a z))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Outputs
(+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Calls

1 calls:

18.0ms
z
Results
AccuracySegmentsBranch
81.5%4z
Compiler

Compiled 9 to 8 computations (11.1% saved)

regimes53.0ms (0.4%)

Counts
54 → 4
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
(+.f64 a (*.f64 y i))
(+.f64 z (*.f64 y i))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z))
(/.f64 (*.f64 z z) z)
(*.f64 i (+.f64 y (/.f64 z i)))
(*.f64 y (+.f64 i (/.f64 z y)))
(*.f64 y (+.f64 (/.f64 a y) i))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 (*.f64 i i) y))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (*.f64 y i) y) i)) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z (*.f64 y i)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 c) b)
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (+.f64 a z))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Outputs
(+.f64 z (*.f64 y i))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Calls

2 calls:

27.0ms
a
18.0ms
z
Results
AccuracySegmentsBranch
68.4%3a
79.6%4z
Compiler

Compiled 18 to 16 computations (11.1% saved)

regimes93.0ms (0.7%)

Counts
53 → 3
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
(+.f64 a (*.f64 y i))
(+.f64 z (*.f64 y i))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z))
(/.f64 (*.f64 z z) z)
(*.f64 i (+.f64 y (/.f64 z i)))
(*.f64 y (+.f64 i (/.f64 z y)))
(*.f64 y (+.f64 (/.f64 a y) i))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 (*.f64 i i) y))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (*.f64 y i) y) i)) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z (*.f64 y i)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 c) b)
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (+.f64 a z))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
Outputs
(+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))))
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 y i))
Calls

5 calls:

19.0ms
z
17.0ms
t
17.0ms
y
16.0ms
x
15.0ms
i
Results
AccuracySegmentsBranch
72.8%3x
69.4%6t
73.8%3y
73.6%3i
71.1%4z
Compiler

Compiled 45 to 40 computations (11.1% saved)

regimes45.0ms (0.3%)

Counts
52 → 3
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
(+.f64 a (*.f64 y i))
(+.f64 z (*.f64 y i))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z))
(/.f64 (*.f64 z z) z)
(*.f64 i (+.f64 y (/.f64 z i)))
(*.f64 y (+.f64 i (/.f64 z y)))
(*.f64 y (+.f64 (/.f64 a y) i))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 (*.f64 i i) y))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (*.f64 y i) y) i)) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z (*.f64 y i)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 c) b)
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (+.f64 a z))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(*.f64 y (+.f64 i (*.f64 (log.f64 c) (/.f64 (+.f64 b #s(literal -1/2 binary64)) y))))
Outputs
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z))
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 y i))
Calls

2 calls:

16.0ms
i
16.0ms
y
Results
AccuracySegmentsBranch
73.0%3i
73.4%3y
Compiler

Compiled 18 to 16 computations (11.1% saved)

regimes55.0ms (0.4%)

Counts
50 → 3
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
(+.f64 a (*.f64 y i))
(+.f64 z (*.f64 y i))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z))
(/.f64 (*.f64 z z) z)
(*.f64 i (+.f64 y (/.f64 z i)))
(*.f64 y (+.f64 i (/.f64 z y)))
(*.f64 y (+.f64 (/.f64 a y) i))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 (*.f64 i i) y))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (*.f64 y i) y) i)) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z (*.f64 y i)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 c) b)
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
(+.f64 (*.f64 (log.f64 c) b) (+.f64 a z))
(+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) a)
Outputs
(+.f64 (*.f64 (log.f64 c) b) (+.f64 a z))
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 y i))
Calls

3 calls:

15.0ms
i
15.0ms
x
15.0ms
y
Results
AccuracySegmentsBranch
70.6%3x
73.1%4i
71.9%3y
Compiler

Compiled 27 to 24 computations (11.1% saved)

regimes196.0ms (1.5%)

Counts
48 → 3
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
(+.f64 a (*.f64 y i))
(+.f64 z (*.f64 y i))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z))
(/.f64 (*.f64 z z) z)
(*.f64 i (+.f64 y (/.f64 z i)))
(*.f64 y (+.f64 i (/.f64 z y)))
(*.f64 y (+.f64 (/.f64 a y) i))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 (*.f64 i i) y))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (*.f64 y i) y) i)) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z (*.f64 y i)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 c) b)
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 z (*.f64 x (log.f64 y)))
(+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))
Outputs
(+.f64 z (*.f64 y i))
(+.f64 a (*.f64 x (log.f64 y)))
(+.f64 a (*.f64 y i))
Calls

9 calls:

43.0ms
y
32.0ms
x
21.0ms
(log.f64 c)
16.0ms
z
16.0ms
c
Results
AccuracySegmentsBranch
66.7%7t
52.1%4c
52.1%4(log.f64 c)
61.8%2a
65.8%8b
64.5%3z
60.8%4x
58.3%3i
61.9%3y
Compiler

Compiled 82 to 73 computations (11% saved)

regimes23.0ms (0.2%)

Counts
45 → 2
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
(+.f64 a (*.f64 y i))
(+.f64 z (*.f64 y i))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z))
(/.f64 (*.f64 z z) z)
(*.f64 i (+.f64 y (/.f64 z i)))
(*.f64 y (+.f64 i (/.f64 z y)))
(*.f64 y (+.f64 (/.f64 a y) i))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 i y) z)))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z)))
(*.f64 (/.f64 z (-.f64 z (*.f64 y i))) z)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 y i))))
(/.f64 (*.f64 z z) (-.f64 #s(literal 0 binary64) (*.f64 y i)))
(/.f64 (*.f64 z z) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (*.f64 z z)))
(+.f64 z (*.f64 i (+.f64 (*.f64 i (/.f64 (*.f64 y y) z)) y)))
(+.f64 z (*.f64 y (+.f64 (/.f64 (*.f64 y (*.f64 i i)) z) i)))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 i (*.f64 i (*.f64 y y)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y (*.f64 (*.f64 i i) y))) (-.f64 z (*.f64 y i)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (*.f64 (*.f64 y i) y) i)) (-.f64 z (*.f64 y i)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (*.f64 y i)) (-.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))
(*.f64 (*.f64 z z) (+.f64 (/.f64 (-.f64 #s(literal 0 binary64) z) (*.f64 (*.f64 y i) (*.f64 y i))) (/.f64 #s(literal -1 binary64) (*.f64 y i))))
(/.f64 (*.f64 y (*.f64 y (-.f64 (/.f64 (*.f64 z z) (*.f64 y y)) (*.f64 i i)))) (-.f64 z (*.f64 y i)))
(/.f64 (*.f64 (*.f64 i i) (-.f64 (/.f64 (*.f64 z z) (*.f64 i i)) (*.f64 y y))) (-.f64 z (*.f64 y i)))
(/.f64 (+.f64 (/.f64 (*.f64 z z) i) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 y (*.f64 i i)))) (-.f64 #s(literal 0 binary64) y))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 (*.f64 i i) (/.f64 (*.f64 y y) z)) (*.f64 y i)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) z))
(-.f64 (*.f64 z (/.f64 z (-.f64 z (*.f64 y i)))) (/.f64 (*.f64 y (*.f64 i (*.f64 y i))) (-.f64 z (*.f64 y i))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (-.f64 z (*.f64 y i))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 y i) (*.f64 y i)) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (*.f64 z z) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))))
(*.f64 (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (-.f64 (*.f64 y i) z))) (+.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 z (*.f64 z z)))))
(/.f64 (+.f64 (+.f64 (*.f64 (*.f64 y i) (-.f64 #s(literal 0 binary64) (*.f64 y i))) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i)))) (-.f64 z (*.f64 y i)))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (*.f64 i (*.f64 y (-.f64 (*.f64 y i) z))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 y i) (*.f64 (*.f64 y i) (*.f64 y i))) (*.f64 z (*.f64 z z)))))
(/.f64 (/.f64 (-.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 y (*.f64 (*.f64 i (*.f64 y i)) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))) (-.f64 z (*.f64 y i)))
(*.f64 (/.f64 (*.f64 (+.f64 z (*.f64 y i)) (-.f64 z (*.f64 y i))) (-.f64 (*.f64 z (*.f64 z z)) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (+.f64 (*.f64 z z) (*.f64 (*.f64 y i) (+.f64 z (*.f64 y i)))))
(/.f64 (-.f64 (*.f64 (*.f64 z z) (*.f64 z (*.f64 z (*.f64 z z)))) (*.f64 (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))) (*.f64 (*.f64 y i) (*.f64 y (*.f64 i (*.f64 y i)))))) (*.f64 (-.f64 z (*.f64 y i)) (+.f64 (*.f64 z (*.f64 z (*.f64 z z))) (*.f64 (*.f64 y (*.f64 i (*.f64 y i))) (+.f64 (*.f64 z z) (*.f64 y (*.f64 i (*.f64 y i))))))))
(*.f64 x (log.f64 y))
(*.f64 (log.f64 c) b)
Outputs
(+.f64 z (*.f64 y i))
(+.f64 a (*.f64 y i))
Calls

1 calls:

20.0ms
z
Results
AccuracySegmentsBranch
61.9%2z
Compiler

Compiled 9 to 8 computations (11.1% saved)

regimes24.0ms (0.2%)

Counts
6 → 2
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
(+.f64 a (*.f64 y i))
Outputs
z
(+.f64 a (*.f64 y i))
Calls

7 calls:

6.0ms
t
3.0ms
b
3.0ms
x
3.0ms
z
3.0ms
a
Results
AccuracySegmentsBranch
48.9%3b
50.1%3i
45.6%1x
52.5%2t
49.1%2y
49.9%2a
55.6%2z
Compiler

Compiled 63 to 56 computations (11.1% saved)

regimes23.0ms (0.2%)

Counts
5 → 3
Calls
Call 1
Inputs
a
z
(*.f64 i y)
(*.f64 y i)
(*.f64 y (/.f64 a y))
Outputs
z
(*.f64 i y)
a
Calls

8 calls:

4.0ms
z
3.0ms
b
2.0ms
t
2.0ms
a
2.0ms
c
Results
AccuracySegmentsBranch
29.7%3x
37.5%7b
40.9%3i
31.6%4c
40.8%3y
42.4%3a
39.6%3t
42.3%3z
Compiler

Compiled 72 to 64 computations (11.1% saved)

regimes7.0ms (0.1%)

Counts
2 → 2
Calls
Call 1
Inputs
a
z
Outputs
z
a
Calls

4 calls:

2.0ms
a
2.0ms
i
2.0ms
z
2.0ms
y
Results
AccuracySegmentsBranch
25.3%2y
27.2%3i
38.2%2z
38.2%2a
Compiler

Compiled 36 to 32 computations (11.1% saved)

regimes21.0ms (0.2%)

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts
1 → 1
Calls
Call 1
Inputs
a
Outputs
a
Calls

8 calls:

11.0ms
a
1.0ms
z
1.0ms
x
1.0ms
t
1.0ms
c
Results
AccuracySegmentsBranch
21.8%1y
21.8%1i
21.8%1x
21.8%1c
21.8%1b
21.8%1t
21.8%1z
21.8%1a
Compiler

Compiled 72 to 64 computations (11.1% saved)

bsearch16.0ms (0.1%)

Algorithm
1×binary-search
Stop Event
1×narrow-enough
Steps
TimeLeftRight
14.0ms
126705524952053.94
418718611171428.9
Results
11.0ms80×0valid
Compiler

Compiled 285 to 210 computations (26.3% saved)

Precisions
Click to see histograms. Total time spent on operations: 6.0ms
ival-log: 2.0ms (32.5% of total)
ival-add: 2.0ms (32.5% of total)
ival-mult: 2.0ms (32.5% of total)
ival-sub: 0.0ms (0% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

bsearch61.0ms (0.5%)

Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
27.0ms
1.1492572122238856e+198
1.9977950948959247e+207
29.0ms
-2.179126647312135e+181
-2.9591059301319207e+169
Results
45.0ms304×0valid
Compiler

Compiled 870 to 650 computations (25.3% saved)

Precisions
Click to see histograms. Total time spent on operations: 27.0ms
ival-log: 9.0ms (33.5% of total)
ival-add: 8.0ms (29.8% of total)
ival-mult: 7.0ms (26.1% of total)
ival-sub: 3.0ms (11.2% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

bsearch82.0ms (0.6%)

Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
48.0ms
1.1492572122238856e+198
1.9977950948959247e+207
30.0ms
-2.179126647312135e+181
-2.9591059301319207e+169
Results
66.0ms304×0valid
Compiler

Compiled 800 to 600 computations (25% saved)

Precisions
Click to see histograms. Total time spent on operations: 25.0ms
ival-log: 8.0ms (31.5% of total)
ival-add: 8.0ms (31.5% of total)
ival-mult: 7.0ms (27.6% of total)
ival-sub: 2.0ms (7.9% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

bsearch78.0ms (0.6%)

Algorithm
3×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
25.0ms
-9.160576558108065e+69
-1.981025320338184e+68
22.0ms
-8.231164284375328e+104
-4.679367730747612e+103
24.0ms
-2.261299980022476e+219
-7.049140792211559e+215
Results
52.0ms350×0valid
1.0ms2×1valid
Compiler

Compiled 894 to 685 computations (23.4% saved)

Precisions
Click to see histograms. Total time spent on operations: 32.0ms
ival-log: 11.0ms (34.5% of total)
ival-mult: 10.0ms (31.3% of total)
ival-add: 8.0ms (25.1% of total)
ival-sub: 2.0ms (6.3% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

bsearch87.0ms (0.7%)

Algorithm
3×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
35.0ms
-9.160576558108065e+69
-1.981025320338184e+68
21.0ms
-8.231164284375328e+104
-4.679367730747612e+103
24.0ms
-2.261299980022476e+219
-7.049140792211559e+215
Results
66.0ms352×0valid
Compiler

Compiled 880 to 678 computations (23% saved)

Precisions
Click to see histograms. Total time spent on operations: 28.0ms
ival-log: 9.0ms (32.5% of total)
ival-add: 8.0ms (28.9% of total)
ival-mult: 8.0ms (28.9% of total)
ival-sub: 2.0ms (7.2% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

bsearch80.0ms (0.6%)

Algorithm
3×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
25.0ms
-9.160576558108065e+69
-1.981025320338184e+68
21.0ms
-8.231164284375328e+104
-4.679367730747612e+103
28.0ms
-2.261299980022476e+219
-7.049140792211559e+215
Results
60.0ms349×0valid
1.0ms3×1valid
Compiler

Compiled 824 to 638 computations (22.6% saved)

Precisions
Click to see histograms. Total time spent on operations: 35.0ms
ival-log: 16.0ms (45.8% of total)
ival-add: 8.0ms (22.9% of total)
ival-mult: 8.0ms (22.9% of total)
ival-sub: 2.0ms (5.7% of total)
const: 1.0ms (2.9% of total)
backward-pass: 0.0ms (0% of total)

bsearch58.0ms (0.4%)

Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
14.0ms
126705524952053.94
418718611171428.9
41.0ms
0.23358373914634212
400.99568040083903
Results
47.0ms208×0valid
Compiler

Compiled 473 to 369 computations (22% saved)

Precisions
Click to see histograms. Total time spent on operations: 16.0ms
ival-log: 5.0ms (30.8% of total)
ival-add: 5.0ms (30.8% of total)
ival-mult: 5.0ms (30.8% of total)
ival-sub: 1.0ms (6.2% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

bsearch43.0ms (0.3%)

Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
15.0ms
126705524952053.94
418718611171428.9
24.0ms
0.23358373914634212
400.99568040083903
Results
32.0ms208×0valid
Compiler

Compiled 457 to 361 computations (21% saved)

Precisions
Click to see histograms. Total time spent on operations: 16.0ms
ival-log: 5.0ms (30.6% of total)
ival-add: 5.0ms (30.6% of total)
ival-mult: 5.0ms (30.6% of total)
ival-sub: 1.0ms (6.1% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

bsearch61.0ms (0.5%)

Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
33.0ms
126705524952053.94
418718611171428.9
24.0ms
0.23358373914634212
400.99568040083903
Results
51.0ms208×0valid
Compiler

Compiled 441 to 345 computations (21.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 39.0ms
ival-mult: 27.0ms (70% of total)
ival-log: 5.0ms (13% of total)
ival-add: 5.0ms (13% of total)
ival-sub: 1.0ms (2.6% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

bsearch47.0ms (0.4%)

Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
21.0ms
-9.160576558108065e+69
-1.981025320338184e+68
20.0ms
-2.7181390658593684e+117
-1.1149140180029509e+116
Results
33.0ms224×0valid
Compiler

Compiled 446 to 352 computations (21.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 20.0ms
ival-add: 8.0ms (39.2% of total)
ival-log: 6.0ms (29.4% of total)
ival-mult: 5.0ms (24.5% of total)
ival-sub: 1.0ms (4.9% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

bsearch23.0ms (0.2%)

Algorithm
1×binary-search
Stop Event
1×narrow-enough
Steps
TimeLeftRight
21.0ms
-2.7181390658593684e+117
-1.1149140180029509e+116
Results
17.0ms112×0valid
Compiler

Compiled 236 to 184 computations (22% saved)

Precisions
Click to see histograms. Total time spent on operations: 10.0ms
ival-log: 4.0ms (39.1% of total)
ival-add: 3.0ms (29.3% of total)
ival-mult: 3.0ms (29.3% of total)
ival-sub: 1.0ms (9.8% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

bsearch19.0ms (0.1%)

Algorithm
1×binary-search
Stop Event
1×narrow-enough
Steps
TimeLeftRight
17.0ms
-8.509064582033024e+140
-9.414483473140413e+139
Results
14.0ms96×0valid
Compiler

Compiled 184 to 150 computations (18.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 9.0ms
ival-mult: 3.0ms (34.9% of total)
ival-log: 2.0ms (23.3% of total)
ival-add: 2.0ms (23.3% of total)
ival-sub: 0.0ms (0% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

bsearch42.0ms (0.3%)

Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
15.0ms
9.326808545499147e+99
2.4457286447821467e+100
24.0ms
4.1329336004766425e-69
1.1196596576187247e-67
Results
30.0ms192×0valid
Compiler

Compiled 304 to 258 computations (15.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 16.0ms
ival-log: 6.0ms (36.7% of total)
ival-add: 5.0ms (30.6% of total)
ival-mult: 5.0ms (30.6% of total)
ival-sub: 1.0ms (6.1% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

bsearch38.0ms (0.3%)

Algorithm
1×binary-search
Stop Event
1×narrow-enough
Steps
TimeLeftRight
16.0ms
2.8811981747848164e+55
1.345500249609896e+56
Results
13.0ms96×0valid
Compiler

Compiled 160 to 138 computations (13.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 8.0ms
ival-log: 2.0ms (26.5% of total)
ival-add: 2.0ms (26.5% of total)
ival-mult: 2.0ms (26.5% of total)
ival-sub: 0.0ms (0% of total)
const: 0.0ms (0% of total)
backward-pass: 0.0ms (0% of total)

simplify15.0ms (0.1%)

Algorithm
1×egg-herbie
Rules
64×+-commutative_binary64
12×*-commutative_binary64
4×sub-neg_binary64
2×neg-sub0_binary64
2×neg-mul-1_binary64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0121444
1162444
2167444
3169444
4170444
Stop Event
1×saturated
Calls
Call 1
Inputs
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(if (<=.f64 y #s(literal 240000000000000 binary64)) (+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) (+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)))
(if (<=.f64 x #s(literal -7800000000000000164276413467399129787576269302337772073730063814163823390426797563696381939563588795115391892353544469751191874847009355735821518990372135589953961667829292851003392 binary64)) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) (if (<=.f64 x #s(literal 5800000000000000074095463664325702282637609488604231376544060376708753623772072441384267219031290331635798384820493112623250960400995573338222166346914758754824310621830139756280343764725872710000257794048 binary64)) (+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) (+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))))
(if (<=.f64 x #s(literal -8600000000000000738898301499318608487981932624712402132747493600576197696336554870043628037538781250168907097967576530528175325990298317855818803797744607350307511647074355511296 binary64)) (+.f64 (*.f64 x (log.f64 y)) (*.f64 y i)) (if (<=.f64 x #s(literal 36999999999999998052875973498797358123128231133539777239498848619305205410327964923971299112224501715953625665806663144589583989569392721910213760476036618602993723685837426268212291272073557461516039487488 binary64)) (+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) (+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))))
(if (<=.f64 z #s(literal -3199999999999999701132701966433581044889251084460867402198085408455386477360490885871591820169539418480577633152493256409208412148089733300765895495142942356892991805457500959908186422137304125306417176755311160066048 binary64)) (+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) (if (<=.f64 z #s(literal -47000000000000003272905442052163940396596279121117401167101130289196219856556923646398879700298078617600 binary64)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (if (<=.f64 z #s(literal -8999999999999999886535157000818686956251856111664105790294330307510272 binary64)) (+.f64 z (*.f64 x (log.f64 y))) (+.f64 (+.f64 (+.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)))))
(if (<=.f64 z #s(literal -850000000000000064135345951748249172505262047873578192446125693120941366059101601022152309162716885018624395003852008062385136580076212614397518248526482297223178827995862632291319048239896817227513732850873557581824 binary64)) (+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) (if (<=.f64 z #s(literal -47000000000000003272905442052163940396596279121117401167101130289196219856556923646398879700298078617600 binary64)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (if (<=.f64 z #s(literal -8999999999999999886535157000818686956251856111664105790294330307510272 binary64)) (+.f64 z (*.f64 x (log.f64 y))) (+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)))))
(if (<=.f64 z #s(literal -1850000000000000005950039111608392014595827771841883913136568320857911236599429272911827385865902843647389781177847032792234504025682437478852474211297000363746798673680669502164080763150044723379784283694434830631567360 binary64)) (+.f64 z (*.f64 y i)) (if (<=.f64 z #s(literal -57000000000000003292062192909510627758755830393769321278629165435190013098596811206011241151379881852928 binary64)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (if (<=.f64 z #s(literal -8999999999999999886535157000818686956251856111664105790294330307510272 binary64)) (+.f64 z (*.f64 x (log.f64 y))) (+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)))))
(if (<=.f64 y #s(literal 400 binary64)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (if (<=.f64 y #s(literal 230000000000000 binary64)) (+.f64 a (*.f64 x (log.f64 y))) (+.f64 z (*.f64 y i))))
(if (<=.f64 y #s(literal 400 binary64)) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z)) (if (<=.f64 y #s(literal 265000000000000 binary64)) (+.f64 a (*.f64 x (log.f64 y))) (+.f64 z (*.f64 y i))))
(if (<=.f64 y #s(literal 400 binary64)) (+.f64 (*.f64 (log.f64 c) b) (+.f64 a z)) (if (<=.f64 y #s(literal 410000000000000 binary64)) (+.f64 a (*.f64 x (log.f64 y))) (+.f64 z (*.f64 y i))))
(if (<=.f64 z #s(literal -1039999999999999946189769581589135165318858185034020199403139615065269166786686526277088831131619802430832867364831232 binary64)) (+.f64 z (*.f64 y i)) (if (<=.f64 z #s(literal -439999999999999974445249225402031267071671222107875274725295386525696 binary64)) (+.f64 a (*.f64 x (log.f64 y))) (+.f64 a (*.f64 y i))))
(if (<=.f64 z #s(literal -1199999999999999948679276162303830049201770408541390028742302907934202571773047438799486493518027394059025872303685632 binary64)) (+.f64 z (*.f64 y i)) (+.f64 a (*.f64 y i)))
(if (<=.f64 z #s(literal -849999999999999955199171548896841282428276797800855560060951286249000834552602316027764082289320260010543930697992737006817894286510354595840 binary64)) z (+.f64 a (*.f64 y i)))
(if (<=.f64 a #s(literal 5463756259384863/121416805764108066932466369176469931665150427440758720078238275608681517825325531136 binary64)) z (if (<=.f64 a #s(literal 14999999999999999267208920533534235242810259434158468763468571810551997532349366721768062376180973568 binary64)) (*.f64 i y) a))
(if (<=.f64 a #s(literal 122000000000000002065355857100095552567012593087205605376 binary64)) z a)
a
Outputs
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 (+.f64 t (+.f64 (*.f64 x (log.f64 y)) z)) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(if (<=.f64 y #s(literal 240000000000000 binary64)) (+.f64 (+.f64 (+.f64 a (+.f64 t z)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64)))) (*.f64 x (log.f64 y))) (+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)))
(if (<=.f64 y #s(literal 240000000000000 binary64)) (+.f64 (*.f64 x (log.f64 y)) (+.f64 (+.f64 a (+.f64 z t)) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (+.f64 (*.f64 y i) (+.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (+.f64 z a))))
(if (<=.f64 x #s(literal -7800000000000000164276413467399129787576269302337772073730063814163823390426797563696381939563588795115391892353544469751191874847009355735821518990372135589953961667829292851003392 binary64)) (+.f64 (+.f64 (*.f64 x (log.f64 y)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) (if (<=.f64 x #s(literal 5800000000000000074095463664325702282637609488604231376544060376708753623772072441384267219031290331635798384820493112623250960400995573338222166346914758754824310621830139756280343764725872710000257794048 binary64)) (+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) (+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))))
(if (<=.f64 x #s(literal -7800000000000000164276413467399129787576269302337772073730063814163823390426797563696381939563588795115391892353544469751191874847009355735821518990372135589953961667829292851003392 binary64)) (+.f64 (*.f64 y i) (+.f64 (*.f64 x (log.f64 y)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (if (<=.f64 x #s(literal 5800000000000000074095463664325702282637609488604231376544060376708753623772072441384267219031290331635798384820493112623250960400995573338222166346914758754824310621830139756280343764725872710000257794048 binary64)) (+.f64 (*.f64 y i) (+.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (+.f64 z a))) (+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))))
(if (<=.f64 x #s(literal -8600000000000000738898301499318608487981932624712402132747493600576197696336554870043628037538781250168907097967576530528175325990298317855818803797744607350307511647074355511296 binary64)) (+.f64 (*.f64 x (log.f64 y)) (*.f64 y i)) (if (<=.f64 x #s(literal 36999999999999998052875973498797358123128231133539777239498848619305205410327964923971299112224501715953625665806663144589583989569392721910213760476036618602993723685837426268212291272073557461516039487488 binary64)) (+.f64 (+.f64 (+.f64 z a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) (+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))))
(if (<=.f64 x #s(literal -8600000000000000738898301499318608487981932624712402132747493600576197696336554870043628037538781250168907097967576530528175325990298317855818803797744607350307511647074355511296 binary64)) (+.f64 (*.f64 x (log.f64 y)) (*.f64 y i)) (if (<=.f64 x #s(literal 36999999999999998052875973498797358123128231133539777239498848619305205410327964923971299112224501715953625665806663144589583989569392721910213760476036618602993723685837426268212291272073557461516039487488 binary64)) (+.f64 (*.f64 y i) (+.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (+.f64 z a))) (+.f64 (*.f64 x (log.f64 y)) (*.f64 y i))))
(if (<=.f64 z #s(literal -3199999999999999701132701966433581044889251084460867402198085408455386477360490885871591820169539418480577633152493256409208412148089733300765895495142942356892991805457500959908186422137304125306417176755311160066048 binary64)) (+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) (if (<=.f64 z #s(literal -47000000000000003272905442052163940396596279121117401167101130289196219856556923646398879700298078617600 binary64)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (if (<=.f64 z #s(literal -8999999999999999886535157000818686956251856111664105790294330307510272 binary64)) (+.f64 z (*.f64 x (log.f64 y))) (+.f64 (+.f64 (+.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)))))
(if (<=.f64 z #s(literal -3199999999999999701132701966433581044889251084460867402198085408455386477360490885871591820169539418480577633152493256409208412148089733300765895495142942356892991805457500959908186422137304125306417176755311160066048 binary64)) (+.f64 (*.f64 y i) (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (if (<=.f64 z #s(literal -47000000000000003272905442052163940396596279121117401167101130289196219856556923646398879700298078617600 binary64)) (+.f64 a (+.f64 (+.f64 z t) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (if (<=.f64 z #s(literal -8999999999999999886535157000818686956251856111664105790294330307510272 binary64)) (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 (*.f64 y i) (+.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (+.f64 t a))))))
(if (<=.f64 z #s(literal -850000000000000064135345951748249172505262047873578192446125693120941366059101601022152309162716885018624395003852008062385136580076212614397518248526482297223178827995862632291319048239896817227513732850873557581824 binary64)) (+.f64 (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) (if (<=.f64 z #s(literal -47000000000000003272905442052163940396596279121117401167101130289196219856556923646398879700298078617600 binary64)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (if (<=.f64 z #s(literal -8999999999999999886535157000818686956251856111664105790294330307510272 binary64)) (+.f64 z (*.f64 x (log.f64 y))) (+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)))))
(if (<=.f64 z #s(literal -850000000000000064135345951748249172505262047873578192446125693120941366059101601022152309162716885018624395003852008062385136580076212614397518248526482297223178827995862632291319048239896817227513732850873557581824 binary64)) (+.f64 (*.f64 y i) (+.f64 z (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (if (<=.f64 z #s(literal -47000000000000003272905442052163940396596279121117401167101130289196219856556923646398879700298078617600 binary64)) (+.f64 a (+.f64 (+.f64 z t) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (if (<=.f64 z #s(literal -8999999999999999886535157000818686956251856111664105790294330307510272 binary64)) (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 (*.f64 y i) (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))))))
(if (<=.f64 z #s(literal -1850000000000000005950039111608392014595827771841883913136568320857911236599429272911827385865902843647389781177847032792234504025682437478852474211297000363746798673680669502164080763150044723379784283694434830631567360 binary64)) (+.f64 z (*.f64 y i)) (if (<=.f64 z #s(literal -57000000000000003292062192909510627758755830393769321278629165435190013098596811206011241151379881852928 binary64)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (if (<=.f64 z #s(literal -8999999999999999886535157000818686956251856111664105790294330307510272 binary64)) (+.f64 z (*.f64 x (log.f64 y))) (+.f64 (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)))))
(if (<=.f64 z #s(literal -1850000000000000005950039111608392014595827771841883913136568320857911236599429272911827385865902843647389781177847032792234504025682437478852474211297000363746798673680669502164080763150044723379784283694434830631567360 binary64)) (+.f64 z (*.f64 y i)) (if (<=.f64 z #s(literal -57000000000000003292062192909510627758755830393769321278629165435190013098596811206011241151379881852928 binary64)) (+.f64 a (+.f64 (+.f64 z t) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (if (<=.f64 z #s(literal -8999999999999999886535157000818686956251856111664105790294330307510272 binary64)) (+.f64 (*.f64 x (log.f64 y)) z) (+.f64 (*.f64 y i) (+.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))))))
(if (<=.f64 y #s(literal 400 binary64)) (+.f64 a (+.f64 (+.f64 t z) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (if (<=.f64 y #s(literal 230000000000000 binary64)) (+.f64 a (*.f64 x (log.f64 y))) (+.f64 z (*.f64 y i))))
(if (<=.f64 y #s(literal 400 binary64)) (+.f64 a (+.f64 (+.f64 z t) (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))))) (if (<=.f64 y #s(literal 230000000000000 binary64)) (+.f64 (*.f64 x (log.f64 y)) a) (+.f64 z (*.f64 y i))))
(if (<=.f64 y #s(literal 400 binary64)) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 a z)) (if (<=.f64 y #s(literal 265000000000000 binary64)) (+.f64 a (*.f64 x (log.f64 y))) (+.f64 z (*.f64 y i))))
(if (<=.f64 y #s(literal 400 binary64)) (+.f64 (*.f64 (log.f64 c) (+.f64 b #s(literal -1/2 binary64))) (+.f64 z a)) (if (<=.f64 y #s(literal 265000000000000 binary64)) (+.f64 (*.f64 x (log.f64 y)) a) (+.f64 z (*.f64 y i))))
(if (<=.f64 y #s(literal 400 binary64)) (+.f64 (*.f64 (log.f64 c) b) (+.f64 a z)) (if (<=.f64 y #s(literal 410000000000000 binary64)) (+.f64 a (*.f64 x (log.f64 y))) (+.f64 z (*.f64 y i))))
(if (<=.f64 y #s(literal 400 binary64)) (+.f64 (+.f64 z a) (*.f64 b (log.f64 c))) (if (<=.f64 y #s(literal 410000000000000 binary64)) (+.f64 (*.f64 x (log.f64 y)) a) (+.f64 z (*.f64 y i))))
(if (<=.f64 z #s(literal -1039999999999999946189769581589135165318858185034020199403139615065269166786686526277088831131619802430832867364831232 binary64)) (+.f64 z (*.f64 y i)) (if (<=.f64 z #s(literal -439999999999999974445249225402031267071671222107875274725295386525696 binary64)) (+.f64 a (*.f64 x (log.f64 y))) (+.f64 a (*.f64 y i))))
(if (<=.f64 z #s(literal -1039999999999999946189769581589135165318858185034020199403139615065269166786686526277088831131619802430832867364831232 binary64)) (+.f64 z (*.f64 y i)) (if (<=.f64 z #s(literal -439999999999999974445249225402031267071671222107875274725295386525696 binary64)) (+.f64 (*.f64 x (log.f64 y)) a) (+.f64 a (*.f64 y i))))
(if (<=.f64 z #s(literal -1199999999999999948679276162303830049201770408541390028742302907934202571773047438799486493518027394059025872303685632 binary64)) (+.f64 z (*.f64 y i)) (+.f64 a (*.f64 y i)))
(if (<=.f64 z #s(literal -849999999999999955199171548896841282428276797800855560060951286249000834552602316027764082289320260010543930697992737006817894286510354595840 binary64)) z (+.f64 a (*.f64 y i)))
(if (<=.f64 a #s(literal 5463756259384863/121416805764108066932466369176469931665150427440758720078238275608681517825325531136 binary64)) z (if (<=.f64 a #s(literal 14999999999999999267208920533534235242810259434158468763468571810551997532349366721768062376180973568 binary64)) (*.f64 i y) a))
(if (<=.f64 a #s(literal 5463756259384863/121416805764108066932466369176469931665150427440758720078238275608681517825325531136 binary64)) z (if (<=.f64 a #s(literal 14999999999999999267208920533534235242810259434158468763468571810551997532349366721768062376180973568 binary64)) (*.f64 y i) a))
(if (<=.f64 a #s(literal 122000000000000002065355857100095552567012593087205605376 binary64)) z a)
a

soundness1.1s (8.6%)

Rules
4272×*-lowering-*.f32
4272×*-lowering-*.f64
4152×+-lowering-+.f64
4152×+-lowering-+.f32
4130×*-lowering-*.f32
Iterations

Useful iterations: 2 (0.0ms)

IterNodesCost
08697649
130346531
086086531
03316058
111415463
239845316
081405316
03615274
112114717
252164597
081114597
Stop Event
1×fuel
1×iter limit
1×node limit
1×iter limit
1×node limit
1×iter limit
1×node limit
Compiler

Compiled 1234 to 735 computations (40.4% saved)

preprocess222.0ms (1.7%)

Remove

(sort z t a)

Compiler

Compiled 1092 to 356 computations (67.4% saved)

end0.0ms (0%)

Profiling

Loading profile data...