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

Time bar (total: 12.8s)

analyze3.0ms (0%)

Memory
5.9MiB live, 5.9MiB allocated
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
0%0%99.7%0.3%0%0%0%0
0%0%99.7%0.3%0%0%0%1
0%0%99.7%0.3%0%0%0%2
0%0%99.7%0.3%0%0%0%3
0%0%99.7%0.3%0%0%0%4
100%49.9%0%0.3%0%49.9%0%5
Compiler

Compiled 18 to 17 computations (5.6% saved)

sample1.1s (8.4%)

Memory
26.1MiB live, 1 943.2MiB allocated
Samples
754.0ms8 251×0valid
0.0ms3×1valid
0.0ms1×3valid
0.0ms1×2valid
Precisions
Click to see histograms. Total time spent on operations: 483.0ms
ival-log: 139.0ms (28.8% of total)
ival-mult: 125.0ms (25.9% of total)
ival-add: 124.0ms (25.7% of total)
ival-sub: 81.0ms (16.8% of total)
ival-true: 7.0ms (1.5% of total)
...in/eval/compile.rkt:110:19: 3.0ms (0.6% of total)
ival-assert: 3.0ms (0.6% of total)
adjust: 0.0ms (0% of total)
Bogosity

preprocess679.0ms (5.3%)

Memory
14.9MiB live, 730.3MiB allocated
Algorithm
2×egg-herbie
Rules
12 800×accelerator-lowering-fma.f32
12 800×accelerator-lowering-fma.f64
2 968×+-lowering-+.f64
2 968×--lowering--.f32
2 968×+-lowering-+.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0126462
1415457
21604450
35323450
47930450
01516
13416
210116
332116
490016
5238216
6348216
7501216
8586516
9617816
10627716
11628716
12640216
13670616
14682916
15683516
16683516
17684116
18684716
19684716
20686516
21687316
22687316
0809814
Stop Event
1×iter limit
1×node limit
1×node limit
Calls
Call 1
Inputs
(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
Outputs
(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
(+.f64 y (-.f64 (+.f64 x (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64)))))
Call 2
Inputs
(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
(+ (- (+ (+ (neg x) y) z) (* z (log t))) (* (- a 1/2) b))
(+ (- (+ (+ x (neg y)) z) (* z (log t))) (* (- a 1/2) b))
(+ (- (+ (+ x y) (neg z)) (* (neg z) (log t))) (* (- a 1/2) b))
(+ (- (+ (+ x y) z) (* z (log (neg t)))) (* (- a 1/2) b))
(+ (- (+ (+ x y) z) (* z (log t))) (* (- (neg a) 1/2) b))
(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) (neg b)))
(neg (+ (- (+ (+ (neg x) y) z) (* z (log t))) (* (- a 1/2) b)))
(neg (+ (- (+ (+ x (neg y)) z) (* z (log t))) (* (- a 1/2) b)))
(neg (+ (- (+ (+ x y) (neg z)) (* (neg z) (log t))) (* (- a 1/2) b)))
(neg (+ (- (+ (+ x y) z) (* z (log (neg t)))) (* (- a 1/2) b)))
(neg (+ (- (+ (+ x y) z) (* z (log t))) (* (- (neg a) 1/2) b)))
(neg (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) (neg b))))
(+ (- (+ (+ y x) z) (* z (log t))) (* (- a 1/2) b))
(+ (- (+ (+ z y) x) (* x (log t))) (* (- a 1/2) b))
(+ (- (+ (+ t y) z) (* z (log x))) (* (- a 1/2) b))
(+ (- (+ (+ a y) z) (* z (log t))) (* (- x 1/2) b))
(+ (- (+ (+ b y) z) (* z (log t))) (* (- a 1/2) x))
(+ (- (+ (+ x z) y) (* y (log t))) (* (- a 1/2) b))
(+ (- (+ (+ x t) z) (* z (log y))) (* (- a 1/2) b))
(+ (- (+ (+ x a) z) (* z (log t))) (* (- y 1/2) b))
(+ (- (+ (+ x b) z) (* z (log t))) (* (- a 1/2) y))
(+ (- (+ (+ x y) t) (* t (log z))) (* (- a 1/2) b))
(+ (- (+ (+ x y) a) (* a (log t))) (* (- z 1/2) b))
(+ (- (+ (+ x y) b) (* b (log t))) (* (- a 1/2) z))
(+ (- (+ (+ x y) z) (* z (log a))) (* (- t 1/2) b))
(+ (- (+ (+ x y) z) (* z (log b))) (* (- a 1/2) t))
(+ (- (+ (+ x y) z) (* z (log t))) (* (- b 1/2) a))
Outputs
(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
(+ (+ (+ x y) (* z (- 1 (log t)))) (* (+ a -1/2) b))
(+ (- (+ (+ (neg x) y) z) (* z (log t))) (* (- a 1/2) b))
(+ (* (+ a -1/2) b) (+ (- y x) (* z (- 1 (log t)))))
(+ (- (+ (+ x (neg y)) z) (* z (log t))) (* (- a 1/2) b))
(+ (* (+ a -1/2) b) (+ (- x y) (* z (- 1 (log t)))))
(+ (- (+ (+ x y) (neg z)) (* (neg z) (log t))) (* (- a 1/2) b))
(+ x (+ y (+ (* (+ a -1/2) b) (* z (+ -1 (log t))))))
(+ (- (+ (+ x y) z) (* z (log (neg t)))) (* (- a 1/2) b))
(- (+ (+ x y) z) (- (* z (log (neg t))) (* (+ a -1/2) b)))
(+ (- (+ (+ x y) z) (* z (log t))) (* (- (neg a) 1/2) b))
(+ (+ (+ x y) (* z (- 1 (log t)))) (* b (- -1/2 a)))
(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) (neg b)))
(+ x (- (- (+ y z) (* z (log t))) (* (+ a -1/2) b)))
(neg (+ (- (+ (+ (neg x) y) z) (* z (log t))) (* (- a 1/2) b)))
(- (+ (* z (log t)) (- x (+ y z))) (* (+ a -1/2) b))
(neg (+ (- (+ (+ x (neg y)) z) (* z (log t))) (* (- a 1/2) b)))
(- (+ (* z (log t)) (- y (+ x z))) (* (+ a -1/2) b))
(neg (+ (- (+ (+ x y) (neg z)) (* (neg z) (log t))) (* (- a 1/2) b)))
(- (- (* z (- 1 (log t))) (+ x y)) (* (+ a -1/2) b))
(neg (+ (- (+ (+ x y) z) (* z (log (neg t)))) (* (- a 1/2) b)))
(- (- (* z (log (neg t))) (+ (+ x y) z)) (* (+ a -1/2) b))
(neg (+ (- (+ (+ x y) z) (* z (log t))) (* (- (neg a) 1/2) b)))
(+ (- (* z (log t)) (+ (+ x y) z)) (* b (+ a 1/2)))
(neg (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) (neg b))))
(+ (* (+ a -1/2) b) (- (* z (log t)) (+ (+ x y) z)))
(+ (- (+ (+ y x) z) (* z (log t))) (* (- a 1/2) b))
(+ (+ (+ x y) (* z (- 1 (log t)))) (* (+ a -1/2) b))
(+ (- (+ (+ z y) x) (* x (log t))) (* (- a 1/2) b))
(+ (+ x y) (+ (- z (* x (log t))) (* (+ a -1/2) b)))
(+ (- (+ (+ t y) z) (* z (log x))) (* (- a 1/2) b))
(+ (* z (- 1 (log x))) (+ (* (+ a -1/2) b) (+ y t)))
(+ (- (+ (+ a y) z) (* z (log t))) (* (- x 1/2) b))
(+ (+ y a) (+ (* b (+ x -1/2)) (* z (- 1 (log t)))))
(+ (- (+ (+ b y) z) (* z (log t))) (* (- a 1/2) x))
(+ (+ y b) (+ (* x (+ a -1/2)) (* z (- 1 (log t)))))
(+ (- (+ (+ x z) y) (* y (log t))) (* (- a 1/2) b))
(- (+ (+ x y) z) (- (* y (log t)) (* (+ a -1/2) b)))
(+ (- (+ (+ x t) z) (* z (log y))) (* (- a 1/2) b))
(- (+ (* (+ a -1/2) b) (+ x (+ z t))) (* z (log y)))
(+ (- (+ (+ x a) z) (* z (log t))) (* (- y 1/2) b))
(+ (+ (+ x a) (* z (- 1 (log t)))) (* b (+ y -1/2)))
(+ (- (+ (+ x b) z) (* z (log t))) (* (- a 1/2) y))
(+ (+ (+ x b) (* z (- 1 (log t)))) (* y (+ a -1/2)))
(+ (- (+ (+ x y) t) (* t (log z))) (* (- a 1/2) b))
(+ (* (+ a -1/2) b) (- (+ x (+ y t)) (* t (log z))))
(+ (- (+ (+ x y) a) (* a (log t))) (* (- z 1/2) b))
(+ (- (+ x (+ y a)) (* (log t) a)) (* b (+ z -1/2)))
(+ (- (+ (+ x y) b) (* b (log t))) (* (- a 1/2) z))
(+ (- b (* (log t) b)) (+ (+ x y) (* z (+ a -1/2))))
(+ (- (+ (+ x y) z) (* z (log a))) (* (- t 1/2) b))
(+ (+ (+ x y) (* z (- 1 (log a)))) (* b (+ t -1/2)))
(+ (- (+ (+ x y) z) (* z (log b))) (* (- a 1/2) t))
(+ (- (+ (+ x y) z) (* z (log b))) (* t (+ a -1/2)))
(+ (- (+ (+ x y) z) (* z (log t))) (* (- b 1/2) a))
(+ (+ (+ x y) (* z (- 1 (log t)))) (* a (+ b -1/2)))
Symmetry

(sort x y)

explain173.0ms (1.3%)

Memory
14.1MiB live, 244.1MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
00-0-(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
00-0-(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
00-0-(log.f64 t)
00-0-a
00-0-t
00-0-z
00-0-(+.f64 (+.f64 x y) z)
00-0-y
00-0-(*.f64 z (log.f64 t))
00-0-(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
00-0-(+.f64 x y)
00-0-b
00-0-#s(literal 1/2 binary64)
00-0-x
00-0-(-.f64 a #s(literal 1/2 binary64))
Confusion
Predicted +Predicted -
+00
-0256
Precision
0/0
Recall
0/0
Confusion?
Predicted +Predicted MaybePredicted -
+000
-00256
Precision?
0/0
Recall?
0/0
Freqs
test
numberfreq
0256
Total Confusion?
Predicted +Predicted MaybePredicted -
+000
-001
Precision?
0/0
Recall?
0/0
Samples
65.0ms512×0valid
Compiler

Compiled 158 to 64 computations (59.5% saved)

Precisions
Click to see histograms. Total time spent on operations: 32.0ms
ival-log: 9.0ms (27.9% of total)
ival-sub: 8.0ms (24.8% of total)
ival-add: 7.0ms (21.7% of total)
ival-mult: 7.0ms (21.7% of total)
ival-true: 1.0ms (3.1% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

eval0.0ms (0%)

Memory
0.4MiB live, 0.4MiB allocated
Compiler

Compiled 6 to 6 computations (0% saved)

prune1.0ms (0%)

Memory
1.5MiB live, 1.5MiB allocated
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶99.8%
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
Compiler

Compiled 22 to 15 computations (31.8% saved)

simplify594.0ms (4.6%)

Memory
-68.4MiB live, 570.4MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(+.f64 x y)
✓cost-diff0
(+.f64 (+.f64 x y) z)
✓cost-diff0
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
✓cost-diff0
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
Rules
12 800×accelerator-lowering-fma.f32
12 800×accelerator-lowering-fma.f64
2 968×+-lowering-+.f64
2 968×--lowering--.f32
2 968×+-lowering-+.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01555
13455
210155
332155
490055
5238255
6348255
7501255
8586555
9617855
10627755
11628755
12640255
13670655
14682955
15683555
16683555
17684155
18684755
19684755
20686555
21687355
22687355
0809852
Stop Event
1×iter limit
1×node limit
Calls
Call 1
Inputs
(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
(- (+ (+ x y) z) (* z (log t)))
(+ (+ x y) z)
(+ x y)
x
y
z
(* z (log t))
(log t)
t
(* (- a 1/2) b)
(- a 1/2)
a
1/2
b
Outputs
(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
(+.f64 y (-.f64 (+.f64 x (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64)))))
(- (+ (+ x y) z) (* z (log t)))
(-.f64 (+.f64 x y) (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64))))
(+ (+ x y) z)
(+.f64 x (+.f64 y z))
(+ x y)
(+.f64 x y)
x
y
z
(* z (log t))
(*.f64 z (log.f64 t))
(log t)
(log.f64 t)
t
(* (- a 1/2) b)
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
a
1/2
#s(literal 1/2 binary64)
b

localize40.0ms (0.3%)

Memory
28.8MiB live, 66.4MiB allocated
Localize:

Found 4 expressions of interest:

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

Compiled 57 to 17 computations (70.2% saved)

Precisions
Click to see histograms. Total time spent on operations: 15.0ms
ival-mult: 5.0ms (33.5% of total)
ival-log: 4.0ms (26.8% of total)
ival-add: 4.0ms (26.8% of total)
ival-sub: 2.0ms (13.4% of total)
ival-true: 0.0ms (0% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series150.0ms (1.2%)

Memory
-22.7MiB live, 176.3MiB allocated
Counts
7 → 240
Calls
Call 1
Inputs
#<alt (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))>
#<alt (- (+ (+ x y) z) (* z (log t)))>
#<alt (+ (+ x y) z)>
#<alt (+ x y)>
#<alt (* z (log t))>
#<alt (* (- a 1/2) b)>
#<alt (log t)>
Outputs
#<alt (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt x>
#<alt (* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))>
#<alt (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt y>
#<alt (* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))>
#<alt (+ x (+ y (* b (- a 1/2))))>
#<alt (+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))>
#<alt (+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))>
#<alt (+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (* b (- a 1/2))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- a 1/2))>
#<alt (* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))>
#<alt (* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))>
#<alt (* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))>
#<alt (- (+ y z) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt x>
#<alt (* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))>
#<alt (- (+ x z) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt y>
#<alt (* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))>
#<alt (+ x y)>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (+ y z)>
#<alt (+ x (+ y z))>
#<alt (+ x (+ y z))>
#<alt (+ x (+ y z))>
#<alt x>
#<alt (* x (+ 1 (+ (/ y x) (/ z x))))>
#<alt (* x (+ 1 (+ (/ y x) (/ z x))))>
#<alt (* x (+ 1 (+ (/ y x) (/ z x))))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))>
#<alt (+ x z)>
#<alt (+ x (+ y z))>
#<alt (+ x (+ y z))>
#<alt (+ x (+ y z))>
#<alt y>
#<alt (* y (+ 1 (+ (/ x y) (/ z y))))>
#<alt (* y (+ 1 (+ (/ x y) (/ z y))))>
#<alt (* y (+ 1 (+ (/ x y) (/ z y))))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))>
#<alt (+ x y)>
#<alt (+ x (+ y z))>
#<alt (+ x (+ y z))>
#<alt (+ x (+ y z))>
#<alt z>
#<alt (* z (+ 1 (+ (/ x z) (/ y z))))>
#<alt (* z (+ 1 (+ (/ x z) (/ y z))))>
#<alt (* z (+ 1 (+ (/ x z) (/ y z))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))>
#<alt y>
#<alt (+ x y)>
#<alt (+ x y)>
#<alt (+ x y)>
#<alt x>
#<alt (* x (+ 1 (/ y x)))>
#<alt (* x (+ 1 (/ y x)))>
#<alt (* x (+ 1 (/ y x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ y x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ y x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ y x)) 1)))>
#<alt x>
#<alt (+ x y)>
#<alt (+ x y)>
#<alt (+ x y)>
#<alt y>
#<alt (* y (+ 1 (/ x y)))>
#<alt (* y (+ 1 (/ x y)))>
#<alt (* y (+ 1 (/ x y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ x y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ x y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ x y)) 1)))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* -1 (* z (log (/ 1 t))))>
#<alt (* -1 (* z (log (/ 1 t))))>
#<alt (* -1 (* z (log (/ 1 t))))>
#<alt (* -1 (* z (log (/ 1 t))))>
#<alt (* z (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (* z (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (* z (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (* z (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (* -1/2 b)>
#<alt (+ (* -1/2 b) (* a b))>
#<alt (+ (* -1/2 b) (* a b))>
#<alt (+ (* -1/2 b) (* a b))>
#<alt (* a b)>
#<alt (* a (+ b (* -1/2 (/ b a))))>
#<alt (* a (+ b (* -1/2 (/ b a))))>
#<alt (* a (+ b (* -1/2 (/ b a))))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (log t)>
#<alt (log t)>
#<alt (log t)>
#<alt (log t)>
#<alt (* -1 (log (/ 1 t)))>
#<alt (* -1 (log (/ 1 t)))>
#<alt (* -1 (log (/ 1 t)))>
#<alt (* -1 (log (/ 1 t)))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
Calls

60 calls:

TimeVariablePointExpression
47.0ms
t
@0
(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
21.0ms
b
@-inf
(* (- a 1/2) b)
18.0ms
t
@-inf
(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
17.0ms
z
@0
(* z (log t))
17.0ms
a
@-inf
(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))

rewrite532.0ms (4.2%)

Memory
30.8MiB live, 822.2MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
7 722×accelerator-lowering-fma.f32
7 722×accelerator-lowering-fma.f64
4 336×*-lowering-*.f32
4 336×*-lowering-*.f64
3 996×/-lowering-/.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01545
19745
294045
0824644
Stop Event
1×iter limit
1×node limit
Counts
7 → 432
Calls
Call 1
Inputs
(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
(- (+ (+ x y) z) (* z (log t)))
(+ (+ x y) z)
(+ x y)
(* z (log t))
(* (- a 1/2) b)
(log t)
Outputs
(+.f64 x (-.f64 (+.f64 y z) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 (+.f64 x y) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(+.f64 (+.f64 x y) (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 z (-.f64 (+.f64 x y) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 (+.f64 x (+.f64 y z)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(+.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))
(+.f64 (/.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (neg.f64 (/.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(+.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x y)) (-.f64 z (*.f64 z (log.f64 t))))
(+.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z))) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))
(-.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(-.f64 (/.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(-.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z))) (*.f64 z (log.f64 t)))
(-.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (/.f64 (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(-.f64 (/.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (/.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(-.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (+.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))
(fma.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z)))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z)))) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (neg.f64 (/.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))) (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (+.f64 y (-.f64 x z))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (+.f64 y (-.f64 x z))) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))) (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 x x) (*.f64 y y))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 x y))) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 x x) (*.f64 y y))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 x y))) (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))))) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 y (-.f64 x z)))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 y (-.f64 x z)))) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z))))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z))))) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 #s(literal 1 binary64) (+.f64 x y) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 #s(literal 1 binary64) (+.f64 x y) (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z)) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) (+.f64 y z))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 y z))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) (+.f64 y z))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 y z))) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (-.f64 z (+.f64 x y))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (-.f64 z (+.f64 x y))) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))
(fma.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))
(fma.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))
(fma.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))
(/.f64 (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (-.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (-.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (neg.f64 (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (-.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (-.f64 #s(literal 0 binary64) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (-.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (-.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64))) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64))) (+.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (*.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b))) (*.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b))) (*.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))) (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z))))) (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z))))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z))))) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z))))) (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z))))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z))))) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (*.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (*.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b))) (*.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b))) (*.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (*.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (+.f64 y (-.f64 x z)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (*.f64 (+.f64 y (-.f64 x z)) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (-.f64 (*.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (*.f64 (+.f64 y (-.f64 x z)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (+.f64 y (-.f64 x z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (-.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 y (-.f64 x z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 y (-.f64 x z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (-.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 y (-.f64 x z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 y (-.f64 x z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z)))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (*.f64 (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z)))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (*.f64 (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z)))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z)))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) (+.f64 y z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (-.f64 x (+.f64 y z)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (*.f64 (-.f64 x (+.f64 y z)) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (-.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) (+.f64 y z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (*.f64 (-.f64 x (+.f64 y z)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (-.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (-.f64 z (+.f64 x y)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (*.f64 (-.f64 z (+.f64 x y)) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (-.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (*.f64 (-.f64 z (+.f64 x y)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (-.f64 z (+.f64 x y)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (*.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)))) (neg.f64 (+.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (-.f64 (+.f64 y z) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) #s(literal 3 binary64))) (+.f64 (*.f64 x x) (-.f64 (*.f64 (-.f64 (+.f64 y z) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 y z) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (*.f64 x (-.f64 (+.f64 y z) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (*.f64 (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (*.f64 (+.f64 x y) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (*.f64 (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (*.f64 (+.f64 x y) (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (+.f64 (*.f64 z (*.f64 z z)) (pow.f64 (-.f64 (+.f64 x y) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) #s(literal 3 binary64))) (+.f64 (*.f64 z z) (-.f64 (*.f64 (-.f64 (+.f64 x y) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x y) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (*.f64 z (-.f64 (+.f64 x y) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (*.f64 (+.f64 x (+.f64 y z)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (*.f64 (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x y)) #s(literal 3 binary64)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x y)) (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x y))) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x y)) (-.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (pow.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z))) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z))) (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z)))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z))) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 3 binary64))) (+.f64 (*.f64 (/.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (+.f64 (*.f64 (/.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (/.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))))
(/.f64 (-.f64 (pow.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z))) #s(literal 3 binary64)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z))) (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z)))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z))) (*.f64 z (log.f64 t))))))
(/.f64 (-.f64 (*.f64 x x) (*.f64 (-.f64 (+.f64 y z) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 y z) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (-.f64 x (-.f64 (+.f64 y z) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (-.f64 (+.f64 x y) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (-.f64 (+.f64 x y) (-.f64 z (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (-.f64 (+.f64 x y) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x y) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (-.f64 z (-.f64 (+.f64 x y) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (-.f64 (+.f64 x (+.f64 y z)) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x y)) (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (-.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x y)) (-.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z))) (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (-.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z))) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z))) (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y z))) (*.f64 z (log.f64 t))))
(/.f64 (-.f64 (*.f64 (/.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (*.f64 (/.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (+.f64 (/.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))
(*.f64 (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(*.f64 (-.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))))
(*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(*.f64 #s(literal 1 binary64) (+.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(*.f64 (-.f64 (*.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (pow.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(+.f64 x (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))))
(+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(+.f64 y (+.f64 x (-.f64 z (*.f64 z (log.f64 t)))))
(+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))
(+.f64 z (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))))
(+.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))
(+.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (+.f64 x (+.f64 y z)))
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) (+.f64 x y))
(+.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (neg.f64 (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))
(+.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (neg.f64 (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))
(-.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))
(-.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))) (/.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))
(fma.f64 z (log.f64 (/.f64 #s(literal 1 binary64) t)) (+.f64 x (+.f64 y z)))
(fma.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z) (+.f64 x (+.f64 y z)))
(fma.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z)))) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (neg.f64 (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))
(fma.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (neg.f64 (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(fma.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (+.f64 y (-.f64 x z))) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (-.f64 #s(literal 0 binary64) z) (log.f64 t) (+.f64 x (+.f64 y z)))
(fma.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 x x) (*.f64 y y))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 x y))) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))))) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 y (-.f64 x z)))) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z))))) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (+.f64 x y))
(fma.f64 #s(literal 1 binary64) (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 #s(literal -1 binary64) (*.f64 z (log.f64 t)) (+.f64 x (+.f64 y z)))
(fma.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) (+.f64 y z))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 y z))) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (-.f64 z (+.f64 x y))) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))
(fma.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 z (*.f64 z (log.f64 t)))) (+.f64 x y))
(fma.f64 (log.f64 (/.f64 #s(literal 1 binary64) t)) z (+.f64 x (+.f64 y z)))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z))))))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))
(/.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))
(/.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(/.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z))))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y))) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y))) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y))) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (-.f64 x y) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (-.f64 x y) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (-.f64 x y) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (-.f64 x y) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 x x) (*.f64 y y))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 x y)) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 x y)) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 x x) (*.f64 y y))) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 x y)) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (-.f64 #s(literal 0 binary64) (-.f64 x y)) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (-.f64 y x) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (-.f64 y x) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (-.f64 y x) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (-.f64 y x) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (-.f64 x y)) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (-.f64 (*.f64 x x) (*.f64 y y)))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (-.f64 x y)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (-.f64 #s(literal 0 binary64) (-.f64 x y))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 x x) (*.f64 y y))))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (-.f64 #s(literal 0 binary64) (-.f64 x y))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 x y))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (/.f64 #s(literal 1 binary64) (+.f64 x y))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (-.f64 y x)) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (-.f64 (*.f64 y y) (*.f64 x x)))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (-.f64 y x)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (-.f64 x y)) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (-.f64 (*.f64 x x) (*.f64 y y)))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (-.f64 x y)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (-.f64 #s(literal 0 binary64) (-.f64 x y))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 x x) (*.f64 y y))))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (-.f64 #s(literal 0 binary64) (-.f64 x y))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 x y))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) #s(literal 1 binary64))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (/.f64 #s(literal 1 binary64) (+.f64 x y))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (-.f64 y x)) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (-.f64 (*.f64 y y) (*.f64 x x)))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (-.f64 y x)))
(/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (pow.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (pow.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 3 binary64))) (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))) (+.f64 y (-.f64 z (*.f64 z (log.f64 t))))) (*.f64 x (+.f64 y (-.f64 z (*.f64 z (log.f64 t))))))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 x x) (-.f64 (*.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 y (*.f64 y y)) (pow.f64 (+.f64 x (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 3 binary64))) (+.f64 (*.f64 y y) (-.f64 (*.f64 (+.f64 x (-.f64 z (*.f64 z (log.f64 t)))) (+.f64 x (-.f64 z (*.f64 z (log.f64 t))))) (*.f64 y (+.f64 x (-.f64 z (*.f64 z (log.f64 t))))))))
(/.f64 (+.f64 (*.f64 z (*.f64 z z)) (pow.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 z z) (-.f64 (*.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) (-.f64 (+.f64 x y) (*.f64 z (log.f64 t)))) (*.f64 z (-.f64 (+.f64 x y) (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) #s(literal 3 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (+.f64 x (+.f64 y z))))))
(/.f64 (+.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (+.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (-.f64 z (*.f64 z (log.f64 t))) (+.f64 x y)))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) #s(literal 3 binary64)) (pow.f64 (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) #s(literal 3 binary64))) (+.f64 (*.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))) (+.f64 (*.f64 (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))) (*.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) #s(literal 3 binary64)) (pow.f64 (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) #s(literal 3 binary64))) (+.f64 (*.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (+.f64 (*.f64 (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))
(/.f64 (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (-.f64 (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)) (+.f64 x (+.f64 y z))))
(/.f64 (-.f64 (*.f64 x x) (*.f64 (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))) (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))))) (-.f64 x (+.f64 y (-.f64 z (*.f64 z (log.f64 t))))))
(/.f64 (-.f64 (*.f64 x x) (*.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (-.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))
(/.f64 (-.f64 (*.f64 y y) (*.f64 (+.f64 x (-.f64 z (*.f64 z (log.f64 t)))) (+.f64 x (-.f64 z (*.f64 z (log.f64 t)))))) (-.f64 y (+.f64 x (-.f64 z (*.f64 z (log.f64 t))))))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))))) (-.f64 z (-.f64 (+.f64 x y) (*.f64 z (log.f64 t)))))
(/.f64 (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (+.f64 x y))) (-.f64 (-.f64 z (*.f64 z (log.f64 t))) (+.f64 x y)))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))) (*.f64 (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))) (+.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (*.f64 (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (+.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) #s(literal -1 binary64))
(*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))
(*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z)))))))
(*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))
(*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))))
(*.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))
(*.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))
(+.f64 x (+.f64 y z))
(+.f64 y (+.f64 x z))
(+.f64 (+.f64 x y) z)
(+.f64 z (+.f64 x y))
(+.f64 (+.f64 y z) x)
(+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 y (-.f64 x z))) (neg.f64 (/.f64 (*.f64 z z) (+.f64 y (-.f64 x z)))))
(+.f64 (+.f64 z x) y)
(-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 y (-.f64 x z))) (/.f64 (*.f64 z z) (+.f64 y (-.f64 x z))))
(-.f64 (/.f64 (*.f64 x x) (-.f64 x (+.f64 y z))) (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 x (+.f64 y z))))
(-.f64 (/.f64 (*.f64 z z) (-.f64 z (+.f64 x y))) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 z (+.f64 x y))))
(fma.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (/.f64 #s(literal 1 binary64) (+.f64 y (-.f64 x z))) (neg.f64 (/.f64 (*.f64 z z) (+.f64 y (-.f64 x z)))))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) z)
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))) z)
(fma.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) z)
(fma.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))) z)
(fma.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 x x) (*.f64 y y))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 x y))) z)
(fma.f64 (+.f64 (*.f64 y (*.f64 y y)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z)))) x)
(fma.f64 #s(literal 1 binary64) (+.f64 x y) z)
(fma.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) z)
(fma.f64 (-.f64 (*.f64 y y) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 y z)) x)
(/.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))))
(/.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))))
(/.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (+.f64 y (-.f64 x z)))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (neg.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z)))))
(/.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (-.f64 #s(literal 0 binary64) (+.f64 y (-.f64 x z))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z)))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 x (+.f64 y z)) (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) (+.f64 y z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (+.f64 x y)) (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z)))))
(/.f64 (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) (+.f64 y z))) (-.f64 x (+.f64 y z)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (-.f64 z (+.f64 x y)))
(/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 y (-.f64 x z))) (*.f64 (+.f64 y (-.f64 x z)) (*.f64 z z))) (*.f64 (+.f64 y (-.f64 x z)) (+.f64 y (-.f64 x z))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))))) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)))) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 y (-.f64 x z)))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))))) (neg.f64 (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z))))))
(/.f64 (neg.f64 (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) (+.f64 y z)))) (neg.f64 (-.f64 x (+.f64 y z))))
(/.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 z (+.f64 x y))))
(/.f64 (+.f64 (*.f64 y (*.f64 y y)) (pow.f64 (+.f64 x z) #s(literal 3 binary64))) (+.f64 (*.f64 y y) (-.f64 (*.f64 (+.f64 x z) (+.f64 x z)) (*.f64 y (+.f64 x z)))))
(/.f64 (+.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (*.f64 x (*.f64 x x))) (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) x))))
(/.f64 (+.f64 (pow.f64 (+.f64 z x) #s(literal 3 binary64)) (*.f64 y (*.f64 y y))) (+.f64 (*.f64 (+.f64 z x) (+.f64 z x)) (-.f64 (*.f64 y y) (*.f64 (+.f64 z x) y))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 y (-.f64 x z))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 z z) (+.f64 y (-.f64 x z))) #s(literal 3 binary64))) (+.f64 (*.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 y (-.f64 x z))) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 y (-.f64 x z)))) (+.f64 (*.f64 (/.f64 (*.f64 z z) (+.f64 y (-.f64 x z))) (/.f64 (*.f64 z z) (+.f64 y (-.f64 x z)))) (*.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 y (-.f64 x z))) (/.f64 (*.f64 z z) (+.f64 y (-.f64 x z)))))))
(/.f64 (-.f64 (*.f64 y y) (*.f64 (+.f64 x z) (+.f64 x z))) (-.f64 y (+.f64 x z)))
(/.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x x)) (-.f64 (+.f64 y z) x))
(/.f64 (-.f64 (*.f64 (+.f64 z x) (+.f64 z x)) (*.f64 y y)) (-.f64 (+.f64 z x) y))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 y (-.f64 x z))) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 y (-.f64 x z)))) (*.f64 (/.f64 (*.f64 z z) (+.f64 y (-.f64 x z))) (/.f64 (*.f64 z z) (+.f64 y (-.f64 x z))))) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 y (-.f64 x z))) (/.f64 (*.f64 z z) (+.f64 y (-.f64 x z)))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))))
(*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z)))))
(*.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (+.f64 y (-.f64 x z))))
(*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))))))
(*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 y (-.f64 x z)))))
(*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z))))))
(*.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z)))
(*.f64 (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) (+.f64 y z))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 y z))))
(*.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (-.f64 z (+.f64 x y))))
(+.f64 x y)
(+.f64 y x)
(+.f64 (/.f64 (*.f64 x x) (-.f64 x y)) (neg.f64 (/.f64 (*.f64 y y) (-.f64 x y))))
(-.f64 (/.f64 (*.f64 x x) (-.f64 x y)) (/.f64 (*.f64 y y) (-.f64 x y)))
(-.f64 (/.f64 (*.f64 y y) (-.f64 y x)) (/.f64 (*.f64 x x) (-.f64 y x)))
(fma.f64 (*.f64 x x) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (neg.f64 (/.f64 (*.f64 y y) (-.f64 x y))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y))))
(/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (-.f64 x y))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (neg.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))))
(/.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 x x) (*.f64 y y))) (-.f64 #s(literal 0 binary64) (-.f64 x y)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 x y)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 y x) (-.f64 (*.f64 y y) (*.f64 x x))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y))))
(/.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (-.f64 y x))
(/.f64 (-.f64 (*.f64 (*.f64 x x) (-.f64 x y)) (*.f64 (-.f64 x y) (*.f64 y y))) (*.f64 (-.f64 x y) (-.f64 x y)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 x x) (*.f64 y y)))) (neg.f64 (-.f64 #s(literal 0 binary64) (-.f64 x y))))
(/.f64 (neg.f64 (-.f64 (*.f64 y y) (*.f64 x x))) (neg.f64 (-.f64 y x)))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 x x) (-.f64 x y)) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 y y) (-.f64 x y)) #s(literal 3 binary64))) (+.f64 (*.f64 (/.f64 (*.f64 x x) (-.f64 x y)) (/.f64 (*.f64 x x) (-.f64 x y))) (+.f64 (*.f64 (/.f64 (*.f64 y y) (-.f64 x y)) (/.f64 (*.f64 y y) (-.f64 x y))) (*.f64 (/.f64 (*.f64 x x) (-.f64 x y)) (/.f64 (*.f64 y y) (-.f64 x y))))))
(/.f64 (-.f64 (*.f64 (/.f64 (*.f64 x x) (-.f64 x y)) (/.f64 (*.f64 x x) (-.f64 x y))) (*.f64 (/.f64 (*.f64 y y) (-.f64 x y)) (/.f64 (*.f64 y y) (-.f64 x y)))) (+.f64 (/.f64 (*.f64 x x) (-.f64 x y)) (/.f64 (*.f64 y y) (-.f64 x y))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))))
(*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))))
(*.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)))
(*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))))
(*.f64 (-.f64 #s(literal 0 binary64) (-.f64 (*.f64 x x) (*.f64 y y))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (-.f64 x y))))
(*.f64 #s(literal 1 binary64) (+.f64 x y))
(*.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)))
(*.f64 z (log.f64 t))
(*.f64 (log.f64 t) z)
(+.f64 (*.f64 b a) (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 a b) (*.f64 #s(literal -1/2 binary64) b))
(fma.f64 a b (*.f64 #s(literal -1/2 binary64) b))
(fma.f64 b a (*.f64 b #s(literal -1/2 binary64)))
(/.f64 b (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b)))
(/.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))
(/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (neg.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)))) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (neg.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b)) (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b)) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (pow.f64 (*.f64 b a) #s(literal 3 binary64)) (pow.f64 (*.f64 b #s(literal -1/2 binary64)) #s(literal 3 binary64))) (+.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (-.f64 (*.f64 (*.f64 b #s(literal -1/2 binary64)) (*.f64 b #s(literal -1/2 binary64))) (*.f64 (*.f64 b a) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (pow.f64 (*.f64 a b) #s(literal 3 binary64)) (pow.f64 (*.f64 #s(literal -1/2 binary64) b) #s(literal 3 binary64))) (+.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (-.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) b) (*.f64 #s(literal -1/2 binary64) b)) (*.f64 (*.f64 a b) (*.f64 #s(literal -1/2 binary64) b)))))
(/.f64 (-.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (*.f64 (*.f64 b #s(literal -1/2 binary64)) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (*.f64 b a) (*.f64 b #s(literal -1/2 binary64))))
(/.f64 (-.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (*.f64 (*.f64 #s(literal -1/2 binary64) b) (*.f64 #s(literal -1/2 binary64) b))) (-.f64 (*.f64 a b) (*.f64 #s(literal -1/2 binary64) b)))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))))
(log.f64 t)

simplify466.0ms (3.6%)

Memory
28.4MiB live, 850.4MiB allocated
Algorithm
1×egg-herbie
Rules
13 462×accelerator-lowering-fma.f32
13 462×accelerator-lowering-fma.f64
4 556×+-lowering-+.f64
4 556×+-lowering-+.f32
3 920×*-lowering-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
02022480
16242458
220452392
368462392
081352196
Stop Event
1×iter limit
1×node limit
Counts
240 → 240
Calls
Call 1
Inputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
x
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
y
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
y
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(+ x (+ y (* b (- a 1/2))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(* b (- a 1/2))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- a 1/2))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(- (+ y z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
x
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
x
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(- (+ x z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
y
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(+ x y)
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+ y z)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
x
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+ x z)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
y
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+ x y)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
y
(+ x y)
(+ x y)
(+ x y)
x
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
x
(+ x y)
(+ x y)
(+ x y)
y
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* -1 (* z (log (/ 1 t))))
(* -1 (* z (log (/ 1 t))))
(* -1 (* z (log (/ 1 t))))
(* -1 (* z (log (/ 1 t))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(* -1/2 b)
(+ (* -1/2 b) (* a b))
(+ (* -1/2 b) (* a b))
(+ (* -1/2 b) (* a b))
(* a b)
(* a (+ b (* -1/2 (/ b a))))
(* a (+ b (* -1/2 (/ b a))))
(* a (+ b (* -1/2 (/ b a))))
(* a b)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(log t)
(log t)
(log t)
(log t)
(* -1 (log (/ 1 t)))
(* -1 (log (/ 1 t)))
(* -1 (log (/ 1 t)))
(* -1 (log (/ 1 t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(+ (log -1) (* -1 (log (/ -1 t))))
(+ (log -1) (* -1 (log (/ -1 t))))
(+ (log -1) (* -1 (log (/ -1 t))))
Outputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x) (-.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (*.f64 z (/.f64 (log.f64 t) x))))))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x) (-.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (*.f64 z (/.f64 (log.f64 t) x))))))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x) (-.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (*.f64 z (/.f64 (log.f64 t) x))))))
x
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) x)) x)
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) x)) x)
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) x)) x)
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
y
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 (/.f64 x y) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 z y)) (*.f64 z (/.f64 (log.f64 t) y)))) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) y)))
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 (/.f64 x y) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 z y)) (*.f64 z (/.f64 (log.f64 t) y)))) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) y)))
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 (/.f64 x y) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 z y)) (*.f64 z (/.f64 (log.f64 t) y)))) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) y)))
y
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(*.f64 y (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 (*.f64 b (-.f64 #s(literal 1/2 binary64) a)) (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64)))) x) y)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(*.f64 y (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 (*.f64 b (-.f64 #s(literal 1/2 binary64) a)) (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64)))) x) y)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(*.f64 y (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 (*.f64 b (-.f64 #s(literal 1/2 binary64) a)) (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64)))) x) y)))
(+ x (+ y (* b (- a 1/2))))
(+.f64 y (-.f64 x (*.f64 b (-.f64 #s(literal 1/2 binary64) a))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(*.f64 z (+.f64 (/.f64 x z) (-.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 y z)) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) z)) (log.f64 t))))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(*.f64 z (+.f64 (/.f64 x z) (-.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 y z)) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) z)) (log.f64 t))))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(*.f64 z (+.f64 (/.f64 x z) (-.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 y z)) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) z)) (log.f64 t))))
(* z (+ 1 (* -1 (log t))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 (+.f64 y (-.f64 x (*.f64 b (-.f64 #s(literal 1/2 binary64) a)))) z)))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 (+.f64 y (-.f64 x (*.f64 b (-.f64 #s(literal 1/2 binary64) a)))) z)))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 (+.f64 y (-.f64 x (*.f64 b (-.f64 #s(literal 1/2 binary64) a)))) z)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 y (-.f64 x (*.f64 b (-.f64 #s(literal 1/2 binary64) a)))) (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 y (-.f64 x (*.f64 b (-.f64 #s(literal 1/2 binary64) a)))) (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 y (-.f64 x (*.f64 b (-.f64 #s(literal 1/2 binary64) a)))) (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 y (-.f64 x (*.f64 b (-.f64 #s(literal 1/2 binary64) a)))) (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x)) (*.f64 b #s(literal -1/2 binary64)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (+.f64 (+.f64 b (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (*.f64 z (/.f64 (log.f64 t) a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (+.f64 (+.f64 b (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (*.f64 z (/.f64 (log.f64 t) a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (+.f64 (+.f64 b (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (*.f64 z (/.f64 (log.f64 t) a)))))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x)) (*.f64 b #s(literal -1/2 binary64))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x)) (*.f64 b #s(literal -1/2 binary64))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x)) (*.f64 b #s(literal -1/2 binary64))) a)))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal -1/2 binary64))) (*.f64 z (/.f64 (log.f64 t) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal -1/2 binary64))) (*.f64 z (/.f64 (log.f64 t) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal -1/2 binary64))) (*.f64 z (/.f64 (log.f64 t) b))))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 b (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x)) b))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 b (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x)) b))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 b (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x)) b))))
(- (+ y z) (* z (log t)))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
x
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(*.f64 x (-.f64 (+.f64 (/.f64 y x) (+.f64 #s(literal 1 binary64) (/.f64 z x))) (*.f64 z (/.f64 (log.f64 t) x))))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(*.f64 x (-.f64 (+.f64 (/.f64 y x) (+.f64 #s(literal 1 binary64) (/.f64 z x))) (*.f64 z (/.f64 (log.f64 t) x))))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(*.f64 x (-.f64 (+.f64 (/.f64 y x) (+.f64 #s(literal 1 binary64) (/.f64 z x))) (*.f64 z (/.f64 (log.f64 t) x))))
x
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 x (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64))) y) x)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 x (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64))) y) x)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 x (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64))) y) x)))
(- (+ x z) (* z (log t)))
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
y
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (/.f64 x y) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 z y)) (*.f64 z (/.f64 (log.f64 t) y)))))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (/.f64 x y) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 z y)) (*.f64 z (/.f64 (log.f64 t) y)))))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (/.f64 x y) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 z y)) (*.f64 z (/.f64 (log.f64 t) y)))))
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) y)) y)
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) y)) y)
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) y)) y)
(+ x y)
(+.f64 y x)
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 (/.f64 x z) (/.f64 y z))))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 (/.f64 x z) (/.f64 y z))))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 (/.f64 x z) (/.f64 y z))))
(* z (+ 1 (* -1 (log t))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))))
(+ y z)
(+.f64 y z)
(+ x (+ y z))
(+.f64 z (+.f64 y x))
(+ x (+ y z))
(+.f64 z (+.f64 y x))
(+ x (+ y z))
(+.f64 z (+.f64 y x))
x
(* x (+ 1 (+ (/ y x) (/ z x))))
(*.f64 x (+.f64 (/.f64 y x) (+.f64 #s(literal 1 binary64) (/.f64 z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
(*.f64 x (+.f64 (/.f64 y x) (+.f64 #s(literal 1 binary64) (/.f64 z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
(*.f64 x (+.f64 (/.f64 y x) (+.f64 #s(literal 1 binary64) (/.f64 z x))))
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y z) x)) x)
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y z) x)) x)
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y z) x)) x)
(+ x z)
(+.f64 z x)
(+ x (+ y z))
(+.f64 z (+.f64 y x))
(+ x (+ y z))
(+.f64 z (+.f64 y x))
(+ x (+ y z))
(+.f64 z (+.f64 y x))
y
(* y (+ 1 (+ (/ x y) (/ z y))))
(*.f64 y (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 x y) (/.f64 z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
(*.f64 y (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 x y) (/.f64 z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
(*.f64 y (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 x y) (/.f64 z y))))
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z x) y)) y)
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z x) y)) y)
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z x) y)) y)
(+ x y)
(+.f64 y x)
(+ x (+ y z))
(+.f64 z (+.f64 y x))
(+ x (+ y z))
(+.f64 z (+.f64 y x))
(+ x (+ y z))
(+.f64 z (+.f64 y x))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(*.f64 z (+.f64 (/.f64 x z) (+.f64 #s(literal 1 binary64) (/.f64 y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
(*.f64 z (+.f64 (/.f64 x z) (+.f64 #s(literal 1 binary64) (/.f64 y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
(*.f64 z (+.f64 (/.f64 x z) (+.f64 #s(literal 1 binary64) (/.f64 y z))))
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y x) z)) z)
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y x) z)) z)
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y x) z)) z)
y
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
x
(* x (+ 1 (/ y x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 y x)))
(* x (+ 1 (/ y x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 y x)))
(* x (+ 1 (/ y x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 y x)))
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 y x)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 y x)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 y x)))
x
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
y
(* y (+ 1 (/ x y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 x y)))
(* y (+ 1 (/ x y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 x y)))
(* y (+ 1 (/ x y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 x y)))
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 x y)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 x y)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 x y)))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* -1 (* z (log (/ 1 t))))
(*.f64 z (log.f64 t))
(* -1 (* z (log (/ 1 t))))
(*.f64 z (log.f64 t))
(* -1 (* z (log (/ 1 t))))
(*.f64 z (log.f64 t))
(* -1 (* z (log (/ 1 t))))
(*.f64 z (log.f64 t))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(+ (* -1/2 b) (* a b))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(+ (* -1/2 b) (* a b))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(+ (* -1/2 b) (* a b))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* a b)
(*.f64 b a)
(* a (+ b (* -1/2 (/ b a))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* a (+ b (* -1/2 (/ b a))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* a (+ b (* -1/2 (/ b a))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(log t)
(log.f64 t)
(log t)
(log.f64 t)
(log t)
(log.f64 t)
(log t)
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))

eval124.0ms (1%)

Memory
-35.4MiB live, 181.3MiB allocated
Compiler

Compiled 26 552 to 1 869 computations (93% saved)

prune258.0ms (2%)

Memory
19.4MiB live, 255.9MiB allocated
Pruning

18 alts after pruning (18 fresh and 0 done)

PrunedKeptTotal
New65418672
Fresh000
Picked101
Done000
Total65518673
Accuracy
100.0%
Counts
673 → 18
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶99.6%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
49.6%
(+.f64 (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
77.2%
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
57.2%
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
78.7%
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶62.9%
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
81.3%
(+.f64 (*.f64 y (+.f64 (/.f64 x y) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 z y)) (*.f64 z (/.f64 (log.f64 t) y))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
77.8%
(+.f64 (*.f64 x (-.f64 (+.f64 (/.f64 y x) (+.f64 #s(literal 1 binary64) (/.f64 z x))) (*.f64 z (/.f64 (log.f64 t) x)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
78.4%
(+.f64 (*.f64 x (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64))) y) x))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
60.2%
(+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶55.5%
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
21.5%
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
▶73.3%
(*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal -1/2 binary64))) (*.f64 z (/.f64 (log.f64 t) b))))
37.3%
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
24.4%
(*.f64 b a)
71.4%
(*.f64 a (+.f64 (+.f64 b (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (*.f64 z (/.f64 (log.f64 t) a)))))
24.4%
y
▶20.2%
x
Compiler

Compiled 716 to 494 computations (31% saved)

simplify453.0ms (3.5%)

Memory
-14.4MiB live, 818.8MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 15 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(+.f64 (/.f64 x b) (/.f64 y b))
✓cost-diff0
(+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal -1/2 binary64)))
✓cost-diff128
(-.f64 (+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal -1/2 binary64))) (*.f64 z (/.f64 (log.f64 t) b)))
✓cost-diff384
(*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal -1/2 binary64))) (*.f64 z (/.f64 (log.f64 t) b))))
✓cost-diff0
(log.f64 t)
✓cost-diff0
(-.f64 #s(literal 1 binary64) (log.f64 t))
✓cost-diff0
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
✓cost-diff0
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
✓cost-diff0
(-.f64 a #s(literal 1/2 binary64))
✓cost-diff0
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
✓cost-diff0
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓cost-diff0
(+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
✓cost-diff0
(+.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
✓cost-diff0
(/.f64 #s(literal 1 binary64) (+.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
✓cost-diff256
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
Rules
16 556×accelerator-lowering-fma.f32
16 556×accelerator-lowering-fma.f64
2 876×+-lowering-+.f64
2 876×+-lowering-+.f32
2 664×--lowering--.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
037243
188243
2257243
31005241
42689241
56755241
08215227
Stop Event
1×iter limit
1×node limit
Calls
Call 1
Inputs
(/ 1 (/ 1 (+ (+ x (- (+ y z) (* z (log t)))) (* (+ a -1/2) b))))
1
(/ 1 (+ (+ x (- (+ y z) (* z (log t)))) (* (+ a -1/2) b)))
(+ (+ x (- (+ y z) (* z (log t)))) (* (+ a -1/2) b))
(+ x (- (+ y z) (* z (log t))))
x
(- (+ y z) (* z (log t)))
(+ y z)
y
z
(* z (log t))
(log t)
t
(* (+ a -1/2) b)
(+ a -1/2)
a
-1/2
b
x
(+ x (* (- a 1/2) b))
x
(* (- a 1/2) b)
(- a 1/2)
a
1/2
b
(+ (* z (- 1 (log t))) (+ y x))
(* z (- 1 (log t)))
z
(- 1 (log t))
1
(log t)
t
(+ y x)
y
x
(* b (- (+ (+ (/ x b) (/ y b)) (+ (+ a (/ z b)) -1/2)) (* z (/ (log t) b))))
b
(- (+ (+ (/ x b) (/ y b)) (+ (+ a (/ z b)) -1/2)) (* z (/ (log t) b)))
(+ (+ (/ x b) (/ y b)) (+ (+ a (/ z b)) -1/2))
(+ (/ x b) (/ y b))
(/ x b)
x
(/ y b)
y
(+ (+ a (/ z b)) -1/2)
(+ a (/ z b))
a
(/ z b)
z
-1/2
(* z (/ (log t) b))
(/ (log t) b)
(log t)
t
Outputs
(/ 1 (/ 1 (+ (+ x (- (+ y z) (* z (log t)))) (* (+ a -1/2) b))))
(+.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
1
#s(literal 1 binary64)
(/ 1 (+ (+ x (- (+ y z) (* z (log t)))) (* (+ a -1/2) b)))
(/.f64 #s(literal 1 binary64) (+.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+ (+ x (- (+ y z) (* z (log t)))) (* (+ a -1/2) b))
(+.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(+ x (- (+ y z) (* z (log t))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
x
(- (+ y z) (* z (log t)))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(+ y z)
(+.f64 y z)
y
z
(* z (log t))
(*.f64 z (log.f64 t))
(log t)
(log.f64 t)
t
(* (+ a -1/2) b)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(+ a -1/2)
(+.f64 a #s(literal -1/2 binary64))
a
-1/2
#s(literal -1/2 binary64)
b
x
(+ x (* (- a 1/2) b))
(+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
x
(* (- a 1/2) b)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
a
1/2
#s(literal 1/2 binary64)
b
(+ (* z (- 1 (log t))) (+ y x))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
z
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
1
#s(literal 1 binary64)
(log t)
(log.f64 t)
t
(+ y x)
(+.f64 x y)
y
x
(* b (- (+ (+ (/ x b) (/ y b)) (+ (+ a (/ z b)) -1/2)) (* z (/ (log t) b))))
(+.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
b
(- (+ (+ (/ x b) (/ y b)) (+ (+ a (/ z b)) -1/2)) (* z (/ (log t) b)))
(+.f64 a (+.f64 #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (/.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) b))))
(+ (+ (/ x b) (/ y b)) (+ (+ a (/ z b)) -1/2))
(+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 y b) (+.f64 a (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x z)))))
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(/ x b)
(/.f64 x b)
x
(/ y b)
(/.f64 y b)
y
(+ (+ a (/ z b)) -1/2)
(+.f64 (+.f64 a #s(literal -1/2 binary64)) (/.f64 z b))
(+ a (/ z b))
(+.f64 a (/.f64 z b))
a
(/ z b)
(/.f64 z b)
z
-1/2
#s(literal -1/2 binary64)
(* z (/ (log t) b))
(*.f64 z (/.f64 (log.f64 t) b))
(/ (log t) b)
(/.f64 (log.f64 t) b)
(log t)
(log.f64 t)
t

localize145.0ms (1.1%)

Memory
-4.1MiB live, 202.3MiB allocated
Localize:

Found 15 expressions of interest:

NewMetricScoreProgram
✓accuracy97.8%
(+.f64 (/.f64 x b) (/.f64 y b))
✓accuracy96.4%
(+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal -1/2 binary64)))
✓accuracy92.3%
(-.f64 (+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal -1/2 binary64))) (*.f64 z (/.f64 (log.f64 t) b)))
✓accuracy74.1%
(*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal -1/2 binary64))) (*.f64 z (/.f64 (log.f64 t) b))))
✓accuracy100.0%
(log.f64 t)
✓accuracy100.0%
(-.f64 #s(literal 1 binary64) (log.f64 t))
✓accuracy100.0%
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
✓accuracy99.6%
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
✓accuracy100.0%
(-.f64 a #s(literal 1/2 binary64))
✓accuracy100.0%
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓accuracy100.0%
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
✓accuracy99.9%
(/.f64 #s(literal 1 binary64) (+.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
✓accuracy99.8%
(-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))
✓accuracy99.7%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
✓accuracy99.6%
(*.f64 z (log.f64 t))
Samples
84.0ms256×0valid
Compiler

Compiled 257 to 39 computations (84.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 61.0ms
ival-mult: 26.0ms (42.4% of total)
ival-add: 12.0ms (19.6% of total)
ival-div: 10.0ms (16.3% of total)
ival-sub: 9.0ms (14.7% of total)
ival-log: 4.0ms (6.5% of total)
ival-true: 0.0ms (0% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series74.0ms (0.6%)

Memory
17.9MiB live, 173.9MiB allocated
Counts
17 → 732
Calls
Call 1
Inputs
#<alt (/ 1 (/ 1 (+ (+ x (- (+ y z) (* z (log t)))) (* (+ a -1/2) b))))>
#<alt (/ 1 (+ (+ x (- (+ y z) (* z (log t)))) (* (+ a -1/2) b)))>
#<alt (+ (+ x (- (+ y z) (* z (log t)))) (* (+ a -1/2) b))>
#<alt (+ x (- (+ y z) (* z (log t))))>
#<alt (+ x (* (- a 1/2) b))>
#<alt (* (- a 1/2) b)>
#<alt (- a 1/2)>
#<alt (+ (* z (- 1 (log t))) (+ y x))>
#<alt (* z (- 1 (log t)))>
#<alt (- 1 (log t))>
#<alt (log t)>
#<alt (* b (- (+ (+ (/ x b) (/ y b)) (+ (+ a (/ z b)) -1/2)) (* z (/ (log t) b))))>
#<alt (- (+ (+ (/ x b) (/ y b)) (+ (+ a (/ z b)) -1/2)) (* z (/ (log t) b)))>
#<alt (+ (+ (/ x b) (/ y b)) (+ (+ a (/ z b)) -1/2))>
#<alt (+ (/ x b) (/ y b))>
#<alt (* z (log t))>
#<alt (- (+ y z) (* z (log t)))>
Outputs
#<alt (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt x>
#<alt (* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))>
#<alt (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt y>
#<alt (* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))>
#<alt (+ x (+ y (* b (- a 1/2))))>
#<alt (+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))>
#<alt (+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))>
#<alt (+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (* b (- a 1/2))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- a 1/2))>
#<alt (* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))>
#<alt (* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))>
#<alt (* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))>
#<alt (/ 1 (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))))>
#<alt (+ (* -1 (/ x (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2))) (/ 1 (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))))>
#<alt (+ (* x (- (/ x (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 3)) (/ 1 (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2)))) (/ 1 (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))))>
#<alt (+ (* x (- (* x (+ (* -1 (/ x (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 4))) (/ 1 (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 3)))) (/ 1 (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2)))) (/ 1 (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))))>
#<alt (/ 1 x)>
#<alt (/ (- (+ 1 (/ (* z (log t)) x)) (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) x)>
#<alt (/ (- (+ 1 (+ (* -1 (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))) (pow x 2))) (/ (* z (log t)) x))) (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) x)>
#<alt (/ (- (+ 1 (+ (/ (* z (log t)) x) (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2)) (pow x 3)))) (+ (/ y x) (+ (/ z x) (+ (/ (* b (- a 1/2)) x) (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))) (pow x 2)))))) x)>
#<alt (/ 1 x)>
#<alt (* -1 (/ (- (* -1 (/ (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) x)) 1) x))>
#<alt (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))) x)) (* z (log t))) (+ y (+ z (* b (- a 1/2))))) x)) 1) x))>
#<alt (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2)) x)) (* -1 (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))))) x)) (* z (log t))) (+ y (+ z (* b (- a 1/2))))) x)) 1) x))>
#<alt (/ 1 (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))))>
#<alt (+ (* -1 (/ y (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2))) (/ 1 (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))))>
#<alt (+ (* y (- (/ y (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 3)) (/ 1 (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2)))) (/ 1 (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))))>
#<alt (+ (* y (- (* y (+ (* -1 (/ y (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 4))) (/ 1 (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 3)))) (/ 1 (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2)))) (/ 1 (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))))>
#<alt (/ 1 y)>
#<alt (/ (- (+ 1 (/ (* z (log t)) y)) (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) y)>
#<alt (/ (- (+ 1 (+ (* -1 (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))) (pow y 2))) (/ (* z (log t)) y))) (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) y)>
#<alt (/ (- (+ 1 (+ (/ (* z (log t)) y) (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2)) (pow y 3)))) (+ (/ x y) (+ (/ z y) (+ (/ (* b (- a 1/2)) y) (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))) (pow y 2)))))) y)>
#<alt (/ 1 y)>
#<alt (* -1 (/ (- (* -1 (/ (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) y)) 1) y))>
#<alt (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))) y)) (* z (log t))) (+ x (+ z (* b (- a 1/2))))) y)) 1) y))>
#<alt (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2)) y)) (* -1 (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))))) y)) (* z (log t))) (+ x (+ z (* b (- a 1/2))))) y)) 1) y))>
#<alt (/ 1 (+ x (+ y (* b (- a 1/2)))))>
#<alt (+ (* z (- (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2)))) (/ 1 (+ x (+ y (* b (- a 1/2))))))>
#<alt (+ (* z (- (+ (* -1 (/ (* z (* (- 1 (log t)) (- (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2))))) (+ x (+ y (* b (- a 1/2)))))) (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2))) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2)))) (/ 1 (+ x (+ y (* b (- a 1/2))))))>
#<alt (+ (* z (- (+ (* z (- (/ (* z (* (pow (- 1 (log t)) 2) (- (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2))))) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ (* (- 1 (log t)) (- (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2)))) (+ x (+ y (* b (- a 1/2))))))) (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2))) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2)))) (/ 1 (+ x (+ y (* b (- a 1/2))))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ (+ (* -1 (/ (+ (/ x (pow (- 1 (log t)) 2)) (+ (/ y (pow (- 1 (log t)) 2)) (/ (* b (- a 1/2)) (pow (- 1 (log t)) 2)))) z)) (/ 1 (- 1 (log t)))) z)>
#<alt (/ (- (+ (/ 1 (- 1 (log t))) (/ (* (+ x (+ y (* b (- a 1/2)))) (+ (/ x (pow (- 1 (log t)) 2)) (+ (/ y (pow (- 1 (log t)) 2)) (/ (* b (- a 1/2)) (pow (- 1 (log t)) 2))))) (* (pow z 2) (- 1 (log t))))) (+ (/ x (* z (pow (- 1 (log t)) 2))) (+ (/ y (* z (pow (- 1 (log t)) 2))) (/ (* b (- a 1/2)) (* z (pow (- 1 (log t)) 2)))))) z)>
#<alt (/ (- (+ (* -1 (/ (* (pow (+ x (+ y (* b (- a 1/2)))) 2) (+ (/ x (pow (- 1 (log t)) 2)) (+ (/ y (pow (- 1 (log t)) 2)) (/ (* b (- a 1/2)) (pow (- 1 (log t)) 2))))) (* (pow z 3) (pow (- 1 (log t)) 2)))) (/ 1 (- 1 (log t)))) (+ (* -1 (/ (* (+ x (+ y (* b (- a 1/2)))) (+ (/ x (pow (- 1 (log t)) 2)) (+ (/ y (pow (- 1 (log t)) 2)) (/ (* b (- a 1/2)) (pow (- 1 (log t)) 2))))) (* (pow z 2) (- 1 (log t))))) (+ (/ x (* z (pow (- 1 (log t)) 2))) (+ (/ y (* z (pow (- 1 (log t)) 2))) (/ (* b (- a 1/2)) (* z (pow (- 1 (log t)) 2))))))) z)>
#<alt (/ 1 (* z (+ 1 (* -1 (log t)))))>
#<alt (* -1 (/ (- (+ (/ x (* z (pow (+ 1 (* -1 (log t))) 2))) (+ (/ y (* z (pow (+ 1 (* -1 (log t))) 2))) (/ (* b (- a 1/2)) (* z (pow (+ 1 (* -1 (log t))) 2))))) (/ 1 (+ 1 (* -1 (log t))))) z))>
#<alt (* -1 (/ (- (* -1 (/ (- (/ (* (+ x (+ y (* b (- a 1/2)))) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) (* z (+ 1 (* -1 (log t))))) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) z)) (/ 1 (+ 1 (* -1 (log t))))) z))>
#<alt (* -1 (/ (- (* -1 (/ (- (* -1 (/ (- (/ (* (pow (+ x (+ y (* b (- a 1/2)))) 2) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) (* z (pow (+ 1 (* -1 (log t))) 2))) (/ (* (+ x (+ y (* b (- a 1/2)))) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) (+ 1 (* -1 (log t))))) z)) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) z)) (/ 1 (+ 1 (* -1 (log t))))) z))>
#<alt (/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))))>
#<alt (/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))))>
#<alt (/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))))>
#<alt (/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))))>
#<alt (/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t))))))>
#<alt (/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t))))))>
#<alt (/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t))))))>
#<alt (/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t))))))>
#<alt (/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t)))))))>
#<alt (/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t)))))))>
#<alt (/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t)))))))>
#<alt (/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t)))))))>
#<alt (/ 1 (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))))>
#<alt (+ (* -1 (/ (* a b) (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2))) (/ 1 (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))))>
#<alt (+ (* a (- (/ (* a (pow b 2)) (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 3)) (/ b (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))))>
#<alt (+ (* a (- (* a (- (* -1 (/ (* a (pow b 3)) (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 4))) (* -1 (/ (pow b 2) (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 3))))) (/ b (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))))>
#<alt (/ 1 (* a b))>
#<alt (/ (- (+ (/ 1/2 (* a b)) (+ (/ 1 b) (/ (* z (log t)) (* a (pow b 2))))) (+ (/ x (* a (pow b 2))) (+ (/ y (* a (pow b 2))) (/ z (* a (pow b 2)))))) a)>
#<alt (/ (- (+ (* -1 (/ (* (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* (pow a 2) b))) (+ (/ 1/2 (* a b)) (+ (/ 1 b) (/ (* z (log t)) (* a (pow b 2)))))) (+ (/ x (* a (pow b 2))) (+ (/ y (* a (pow b 2))) (/ z (* a (pow b 2)))))) a)>
#<alt (/ (- (+ (/ 1/2 (* a b)) (+ (/ 1 b) (+ (/ (* z (log t)) (* a (pow b 2))) (/ (* (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* (pow a 3) (pow b 2)))))) (+ (/ x (* a (pow b 2))) (+ (/ y (* a (pow b 2))) (+ (/ z (* a (pow b 2))) (/ (* (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* (pow a 2) b)))))) a)>
#<alt (/ 1 (* a b))>
#<alt (* -1 (/ (- (* -1 (/ (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))) a)) (/ 1 b)) a))>
#<alt (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* a b))) (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2)))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))) a)) (/ 1 b)) a))>
#<alt (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* a (pow b 2)))) (* -1 (/ (* (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) b))) a)) (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2)))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))) a)) (/ 1 b)) a))>
#<alt (/ 1 (- (+ x (+ y z)) (* z (log t))))>
#<alt (+ (* b (- (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y z)) (* z (log t)))))>
#<alt (+ (* b (- (+ (* -1 (/ (* b (* (- a 1/2) (- (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2))))) (- (+ x (+ y z)) (* z (log t))))) (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y z)) (* z (log t)))))>
#<alt (+ (* b (- (+ (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (* b (- (/ (* b (* (pow (- a 1/2) 2) (- (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2))))) (pow (- (+ x (+ y z)) (* z (log t))) 2)) (/ (* (- a 1/2) (- (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (- (+ x (+ y z)) (* z (log t))))))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y z)) (* z (log t)))))>
#<alt (/ 1 (* b (- a 1/2)))>
#<alt (/ (- (+ (/ 1 (- a 1/2)) (/ (* z (log t)) (* b (pow (- a 1/2) 2)))) (+ (/ x (* b (pow (- a 1/2) 2))) (+ (/ y (* b (pow (- a 1/2) 2))) (/ z (* b (pow (- a 1/2) 2)))))) b)>
#<alt (/ (- (+ (* -1 (/ (* (- (+ x (+ y z)) (* z (log t))) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* (pow b 2) (- a 1/2)))) (+ (/ 1 (- a 1/2)) (/ (* z (log t)) (* b (pow (- a 1/2) 2))))) (+ (/ x (* b (pow (- a 1/2) 2))) (+ (/ y (* b (pow (- a 1/2) 2))) (/ z (* b (pow (- a 1/2) 2)))))) b)>
#<alt (/ (- (+ (/ 1 (- a 1/2)) (+ (/ (* z (log t)) (* b (pow (- a 1/2) 2))) (/ (* (pow (- (+ x (+ y z)) (* z (log t))) 2) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* (pow b 3) (pow (- a 1/2) 2))))) (+ (/ x (* b (pow (- a 1/2) 2))) (+ (/ y (* b (pow (- a 1/2) 2))) (+ (/ z (* b (pow (- a 1/2) 2))) (/ (* (- (+ x (+ y z)) (* z (log t))) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* (pow b 2) (- a 1/2))))))) b)>
#<alt (/ 1 (* b (- a 1/2)))>
#<alt (* -1 (/ (- (* -1 (/ (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2))))) b)) (/ 1 (- a 1/2))) b))>
#<alt (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* (- (+ x (+ y z)) (* z (log t))) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* b (- a 1/2)))) (/ (* z (log t)) (pow (- a 1/2) 2))) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2))))) b)) (/ 1 (- a 1/2))) b))>
#<alt (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (- (+ x (+ y z)) (* z (log t))) 2) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* b (pow (- a 1/2) 2)))) (* -1 (/ (* (- (+ x (+ y z)) (* z (log t))) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (- a 1/2)))) b)) (/ (* z (log t)) (pow (- a 1/2) 2))) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2))))) b)) (/ 1 (- a 1/2))) b))>
#<alt (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt x>
#<alt (* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))>
#<alt (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt y>
#<alt (* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))>
#<alt (+ x (+ y (* b (- a 1/2))))>
#<alt (+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))>
#<alt (+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))>
#<alt (+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (* b (- a 1/2))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- a 1/2))>
#<alt (* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))>
#<alt (* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))>
#<alt (* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))>
#<alt (- (+ y z) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt x>
#<alt (* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))>
#<alt (- (+ x z) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt y>
#<alt (* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))>
#<alt (+ x y)>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* b (- a 1/2))>
#<alt (+ x (* b (- a 1/2)))>
#<alt (+ x (* b (- a 1/2)))>
#<alt (+ x (* b (- a 1/2)))>
#<alt x>
#<alt (* x (+ 1 (/ (* b (- a 1/2)) x)))>
#<alt (* x (+ 1 (/ (* b (- a 1/2)) x)))>
#<alt (* x (+ 1 (/ (* b (- a 1/2)) x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (* b (- a 1/2)) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (* b (- a 1/2)) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (* b (- a 1/2)) x)) 1)))>
#<alt (+ x (* -1/2 b))>
#<alt (+ x (+ (* -1/2 b) (* a b)))>
#<alt (+ x (+ (* -1/2 b) (* a b)))>
#<alt (+ x (+ (* -1/2 b) (* a b)))>
#<alt (* a b)>
#<alt (* a (+ b (+ (* -1/2 (/ b a)) (/ x a))))>
#<alt (* a (+ b (+ (* -1/2 (/ b a)) (/ x a))))>
#<alt (* a (+ b (+ (* -1/2 (/ b a)) (/ x a))))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (* -1/2 b)) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (* -1/2 b)) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (* -1/2 b)) a)))))>
#<alt x>
#<alt (+ x (* b (- a 1/2)))>
#<alt (+ x (* b (- a 1/2)))>
#<alt (+ x (* b (- a 1/2)))>
#<alt (* b (- a 1/2))>
#<alt (* b (- (+ a (/ x b)) 1/2))>
#<alt (* b (- (+ a (/ x b)) 1/2))>
#<alt (* b (- (+ a (/ x b)) 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ x b)))))>
#<alt (* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ x b)))))>
#<alt (* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ x b)))))>
#<alt (* -1/2 b)>
#<alt (+ (* -1/2 b) (* a b))>
#<alt (+ (* -1/2 b) (* a b))>
#<alt (+ (* -1/2 b) (* a b))>
#<alt (* a b)>
#<alt (* a (+ b (* -1/2 (/ b a))))>
#<alt (* a (+ b (* -1/2 (/ b a))))>
#<alt (* a (+ b (* -1/2 (/ b a))))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt (* b (- a 1/2))>
#<alt -1/2>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt a>
#<alt (* a (- 1 (* 1/2 (/ 1 a))))>
#<alt (* a (- 1 (* 1/2 (/ 1 a))))>
#<alt (* a (- 1 (* 1/2 (/ 1 a))))>
#<alt a>
#<alt (* -1 (* a (- (* 1/2 (/ 1 a)) 1)))>
#<alt (* -1 (* a (- (* 1/2 (/ 1 a)) 1)))>
#<alt (* -1 (* a (- (* 1/2 (/ 1 a)) 1)))>
#<alt (+ x y)>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* -1 (* z (+ (* -1 (- 1 (log t))) (* -1 (/ (+ x y) z)))))>
#<alt (* -1 (* z (+ (* -1 (- 1 (log t))) (* -1 (/ (+ x y) z)))))>
#<alt (* -1 (* z (+ (* -1 (- 1 (log t))) (* -1 (/ (+ x y) z)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (* -1 (log (/ 1 t)))))))>
#<alt (+ x (+ y (* z (- 1 (* -1 (log (/ 1 t)))))))>
#<alt (+ x (+ y (* z (- 1 (* -1 (log (/ 1 t)))))))>
#<alt (+ x (+ y (* z (- 1 (* -1 (log (/ 1 t)))))))>
#<alt (+ x (+ y (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))))>
#<alt (+ x (+ y (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))))>
#<alt (+ x (+ y (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))))>
#<alt (+ x (+ y (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))))>
#<alt (+ x (* z (- 1 (log t))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt y>
#<alt (* y (+ 1 (+ (/ x y) (/ (* z (- 1 (log t))) y))))>
#<alt (* y (+ 1 (+ (/ x y) (/ (* z (- 1 (log t))) y))))>
#<alt (* y (+ 1 (+ (/ x y) (/ (* z (- 1 (log t))) y))))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (+ x (* z (- 1 (log t)))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (+ x (* z (- 1 (log t)))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (+ x (* z (- 1 (log t)))) y)) 1)))>
#<alt (+ y (* z (- 1 (log t))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt x>
#<alt (* x (+ 1 (+ (/ y x) (/ (* z (- 1 (log t))) x))))>
#<alt (* x (+ 1 (+ (/ y x) (/ (* z (- 1 (log t))) x))))>
#<alt (* x (+ 1 (+ (/ y x) (/ (* z (- 1 (log t))) x))))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (+ y (* z (- 1 (log t)))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ y (* z (- 1 (log t)))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ y (* z (- 1 (log t)))) x)) 1)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- 1 (log t))>
#<alt (- 1 (log t))>
#<alt (- 1 (log t))>
#<alt (- 1 (log t))>
#<alt (- 1 (* -1 (log (/ 1 t))))>
#<alt (- 1 (* -1 (log (/ 1 t))))>
#<alt (- 1 (* -1 (log (/ 1 t))))>
#<alt (- 1 (* -1 (log (/ 1 t))))>
#<alt (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (log t)>
#<alt (log t)>
#<alt (log t)>
#<alt (log t)>
#<alt (* -1 (log (/ 1 t)))>
#<alt (* -1 (log (/ 1 t)))>
#<alt (* -1 (log (/ 1 t)))>
#<alt (* -1 (log (/ 1 t)))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (* b (- a 1/2))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- a 1/2))>
#<alt (* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ x b)) (+ (* -1 (/ y b)) (* -1 (/ z b))))) (* -1 (/ (* z (log t)) b)))))>
#<alt (* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ x b)) (+ (* -1 (/ y b)) (* -1 (/ z b))))) (* -1 (/ (* z (log t)) b)))))>
#<alt (* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ x b)) (+ (* -1 (/ y b)) (* -1 (/ z b))))) (* -1 (/ (* z (log t)) b)))))>
#<alt (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt x>
#<alt (* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))>
#<alt (* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))>
#<alt (* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))>
#<alt (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt y>
#<alt (* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))>
#<alt (* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))>
#<alt (* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))>
#<alt (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (* a b)>
#<alt (* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))>
#<alt (* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))>
#<alt (* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))>
#<alt (* b (- (+ a (+ (/ x b) (/ y b))) 1/2))>
#<alt (+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))>
#<alt (+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))>
#<alt (+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))>
#<alt (* b (* z (- (/ 1 b) (/ (log t) b))))>
#<alt (* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))>
#<alt (* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))>
#<alt (* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))>
#<alt (* b (* z (+ (* -1 (/ (log t) b)) (/ 1 b))))>
#<alt (* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))>
#<alt (* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))>
#<alt (* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))>
#<alt (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (/ x b)>
#<alt (* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))>
#<alt (* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))>
#<alt (* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))>
#<alt (/ x b)>
#<alt (* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))>
#<alt (/ (- (+ x (+ y z)) (* z (log t))) b)>
#<alt (/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)>
#<alt (/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)>
#<alt (/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)>
#<alt (- a 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- a 1/2)>
#<alt (- (+ a (* -1 (/ (- (+ (* -1 x) (+ (* -1 y) (* -1 z))) (* -1 (* z (log t)))) b))) 1/2)>
#<alt (- (+ a (* -1 (/ (- (+ (* -1 x) (+ (* -1 y) (* -1 z))) (* -1 (* z (log t)))) b))) 1/2)>
#<alt (- (+ a (* -1 (/ (- (+ (* -1 x) (+ (* -1 y) (* -1 z))) (* -1 (* z (log t)))) b))) 1/2)>
#<alt (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (/ y b)>
#<alt (* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))>
#<alt (* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))>
#<alt (* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))>
#<alt (/ y b)>
#<alt (* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))>
#<alt (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt a>
#<alt (* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))>
#<alt (* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))>
#<alt (* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))>
#<alt (- (+ a (+ (/ x b) (/ y b))) 1/2)>
#<alt (- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)>
#<alt (- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)>
#<alt (- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)>
#<alt (* z (- (/ 1 b) (/ (log t) b)))>
#<alt (* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))>
#<alt (* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))>
#<alt (* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))>
#<alt (* z (+ (* -1 (/ (log t) b)) (/ 1 b)))>
#<alt (* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))>
#<alt (* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))>
#<alt (* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))>
#<alt (- (+ a (+ (/ y b) (/ z b))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (/ x b)>
#<alt (* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (* 1/2 (/ 1 x))))>
#<alt (* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (* 1/2 (/ 1 x))))>
#<alt (* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (* 1/2 (/ 1 x))))>
#<alt (/ x b)>
#<alt (* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) 1/2) x)) (/ 1 b))))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) 1/2) x)) (/ 1 b))))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) 1/2) x)) (/ 1 b))))>
#<alt (/ (+ x (+ y z)) b)>
#<alt (/ (+ x (+ y (+ z (* b (- a 1/2))))) b)>
#<alt (/ (+ x (+ y (+ z (* b (- a 1/2))))) b)>
#<alt (/ (+ x (+ y (+ z (* b (- a 1/2))))) b)>
#<alt (- a 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (- a 1/2)>
#<alt (- (+ a (* -1 (/ (+ (* -1 x) (+ (* -1 y) (* -1 z))) b))) 1/2)>
#<alt (- (+ a (* -1 (/ (+ (* -1 x) (+ (* -1 y) (* -1 z))) b))) 1/2)>
#<alt (- (+ a (* -1 (/ (+ (* -1 x) (+ (* -1 y) (* -1 z))) b))) 1/2)>
#<alt (- (+ a (+ (/ x b) (/ z b))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (/ y b)>
#<alt (* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (* 1/2 (/ 1 y))))>
#<alt (* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (* 1/2 (/ 1 y))))>
#<alt (* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (* 1/2 (/ 1 y))))>
#<alt (/ y b)>
#<alt (* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) 1/2) y)) (/ 1 b))))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) 1/2) y)) (/ 1 b))))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) 1/2) y)) (/ 1 b))))>
#<alt (- (+ (/ x b) (+ (/ y b) (/ z b))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt a>
#<alt (* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (* 1/2 (/ 1 a))))>
#<alt (* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (* 1/2 (/ 1 a))))>
#<alt (* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (* 1/2 (/ 1 a))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) 1/2) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) 1/2) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) 1/2) a)) 1)))>
#<alt (- (+ a (+ (/ x b) (/ y b))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)>
#<alt (/ z b)>
#<alt (* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (* 1/2 (/ 1 z))))>
#<alt (* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (* 1/2 (/ 1 z))))>
#<alt (* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (* 1/2 (/ 1 z))))>
#<alt (/ z b)>
#<alt (* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (/ 1 b))))>
#<alt (* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (/ 1 b))))>
#<alt (* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (/ 1 b))))>
#<alt (/ y b)>
#<alt (+ (/ x b) (/ y b))>
#<alt (+ (/ x b) (/ y b))>
#<alt (+ (/ x b) (/ y b))>
#<alt (/ x b)>
#<alt (* x (+ (/ 1 b) (/ y (* b x))))>
#<alt (* x (+ (/ 1 b) (/ y (* b x))))>
#<alt (* x (+ (/ 1 b) (/ y (* b x))))>
#<alt (/ x b)>
#<alt (* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))>
#<alt (* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))>
#<alt (* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (* -1 (/ (+ (* -1 x) (* -1 y)) b))>
#<alt (* -1 (/ (+ (* -1 x) (* -1 y)) b))>
#<alt (* -1 (/ (+ (* -1 x) (* -1 y)) b))>
#<alt (* -1 (/ (+ (* -1 x) (* -1 y)) b))>
#<alt (/ x b)>
#<alt (+ (/ x b) (/ y b))>
#<alt (+ (/ x b) (/ y b))>
#<alt (+ (/ x b) (/ y b))>
#<alt (/ y b)>
#<alt (* y (+ (/ 1 b) (/ x (* b y))))>
#<alt (* y (+ (/ 1 b) (/ x (* b y))))>
#<alt (* y (+ (/ 1 b) (/ x (* b y))))>
#<alt (/ y b)>
#<alt (* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))>
#<alt (* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))>
#<alt (* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* -1 (* z (log (/ 1 t))))>
#<alt (* -1 (* z (log (/ 1 t))))>
#<alt (* -1 (* z (log (/ 1 t))))>
#<alt (* -1 (* z (log (/ 1 t))))>
#<alt (* z (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (* z (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (* z (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (* z (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (- z (* z (log t)))>
#<alt (- (+ y z) (* z (log t)))>
#<alt (- (+ y z) (* z (log t)))>
#<alt (- (+ y z) (* z (log t)))>
#<alt y>
#<alt (* y (- (+ 1 (/ z y)) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (/ z y)) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (/ z y)) (/ (* z (log t)) y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (- z (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- z (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- z (* z (log t))) y)) 1)))>
#<alt y>
#<alt (+ y (* z (- 1 (log t))))>
#<alt (+ y (* z (- 1 (log t))))>
#<alt (+ y (* z (- 1 (log t))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- (+ 1 (/ y z)) (log t)))>
#<alt (* z (- (+ 1 (/ y z)) (log t)))>
#<alt (* z (- (+ 1 (/ y z)) (log t)))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* -1 (* z (- (* -1 (/ y z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ y z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ y z)) (+ 1 (* -1 (log t))))))>
#<alt (- (+ y z) (* z (log t)))>
#<alt (- (+ y z) (* z (log t)))>
#<alt (- (+ y z) (* z (log t)))>
#<alt (- (+ y z) (* z (log t)))>
#<alt (- (+ y z) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ y z) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ y z) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ y z) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ y z) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ y z) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ y z) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ y z) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
Calls

183 calls:

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

rewrite391.0ms (3.1%)

Memory
5.5MiB live, 673.6MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
4 088×/-lowering-/.f32
4 088×/-lowering-/.f64
3 410×*-lowering-*.f32
3 410×*-lowering-*.f64
2 842×pow-lowering-pow.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
037177
1303177
23230177
08548169
Stop Event
1×iter limit
1×node limit
Counts
17 → 661
Calls
Call 1
Inputs
(/ 1 (/ 1 (+ (+ x (- (+ y z) (* z (log t)))) (* (+ a -1/2) b))))
(/ 1 (+ (+ x (- (+ y z) (* z (log t)))) (* (+ a -1/2) b)))
(+ (+ x (- (+ y z) (* z (log t)))) (* (+ a -1/2) b))
(+ x (- (+ y z) (* z (log t))))
(+ x (* (- a 1/2) b))
(* (- a 1/2) b)
(- a 1/2)
(+ (* z (- 1 (log t))) (+ y x))
(* z (- 1 (log t)))
(- 1 (log t))
(log t)
(* b (- (+ (+ (/ x b) (/ y b)) (+ (+ a (/ z b)) -1/2)) (* z (/ (log t) b))))
(- (+ (+ (/ x b) (/ y b)) (+ (+ a (/ z b)) -1/2)) (* z (/ (log t) b)))
(+ (+ (/ x b) (/ y b)) (+ (+ a (/ z b)) -1/2))
(+ (/ x b) (/ y b))
(* z (log t))
(- (+ y z) (* z (log t)))
Outputs
(+.f64 x (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(+.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))
(+.f64 (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(+.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) x)
(+.f64 (*.f64 x #s(literal 1 binary64)) (*.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)))
(+.f64 (*.f64 #s(literal 1 binary64) x) (*.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))) (*.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))
(+.f64 (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 1 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(literal 1 binary64)))
(+.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(literal 1 binary64)) (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(exp.f64 (*.f64 (log.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64)))
(-.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(-.f64 (/.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(-.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 y z))) (*.f64 z (log.f64 t)))
(fma.f64 #s(literal 1 binary64) x (*.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) (*.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(fma.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))
(fma.f64 x #s(literal 1 binary64) (*.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)))
(fma.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 1 binary64) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(literal 1 binary64)))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))
(fma.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(literal 1 binary64) (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 1 binary64)))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) x)))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)))) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(fma.f64 (-.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 (*.f64 z (log.f64 t)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(fma.f64 (-.f64 (*.f64 x x) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(fma.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(fma.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64))
(/.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))))
(/.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (*.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (+.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (neg.f64 (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (neg.f64 (*.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 3 binary64))) (+.f64 (*.f64 x x) (-.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 2 binary64)) (*.f64 x (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (*.f64 x x) (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 2 binary64))) (-.f64 x (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))
(/.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (neg.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (neg.f64 (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 x x) (-.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 2 binary64)) (*.f64 x (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 x x) (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 2 binary64)))) (neg.f64 (-.f64 x (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) #s(literal -1/2 binary64))
(*.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(*.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(*.f64 #s(literal -1 binary64) (pow.f64 (-.f64 #s(literal 0 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64)))
(*.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))))
(*.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(*.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1/2 binary64)) (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(exp.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) #s(literal 1 binary64)))
(neg.f64 (/.f64 #s(literal -1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (/.f64 #s(literal -1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64))
(pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64))
(pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1/2 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(*.f64 #s(literal -1 binary64) (pow.f64 (/.f64 #s(literal -1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1/2 binary64)) (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) #s(literal 1 binary64)) (pow.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64)) (pow.f64 (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1 binary64)))
(+.f64 x (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(+.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))
(+.f64 (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(+.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) x)
(+.f64 (*.f64 x #s(literal 1 binary64)) (*.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)))
(+.f64 (*.f64 #s(literal 1 binary64) x) (*.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))) (*.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(+.f64 (*.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))
(+.f64 (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 1 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(literal 1 binary64)))
(+.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(literal 1 binary64)) (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 1 binary64)))
(exp.f64 (log.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(exp.f64 (*.f64 (log.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64)))
(-.f64 (+.f64 x (+.f64 y z)) (-.f64 (*.f64 z (log.f64 t)) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(-.f64 (/.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(-.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 y z))) (*.f64 z (log.f64 t)))
(fma.f64 #s(literal 1 binary64) x (*.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) (*.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(fma.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))
(fma.f64 x #s(literal 1 binary64) (*.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)))
(fma.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 1 binary64) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(literal 1 binary64)))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))
(fma.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(literal 1 binary64) (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 1 binary64)))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) x)))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)))) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(fma.f64 (-.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 (*.f64 z (log.f64 t)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(fma.f64 (-.f64 (*.f64 x x) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(fma.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(fma.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64))
(/.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))))
(/.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (*.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (+.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (neg.f64 (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (neg.f64 (*.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 3 binary64))) (+.f64 (*.f64 x x) (-.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 2 binary64)) (*.f64 x (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (*.f64 x x) (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 2 binary64))) (-.f64 x (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))
(/.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (neg.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (neg.f64 (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 x x) (-.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 2 binary64)) (*.f64 x (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 x x) (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 2 binary64)))) (neg.f64 (-.f64 x (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) #s(literal -1/2 binary64))
(*.f64 #s(literal 1 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(*.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(*.f64 #s(literal -1 binary64) (pow.f64 (-.f64 #s(literal 0 binary64) (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64)))
(*.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))))
(*.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(*.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1/2 binary64)) (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 3 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(+.f64 y (+.f64 (-.f64 z (*.f64 z (log.f64 t))) x))
(+.f64 (+.f64 y z) (+.f64 (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))) x))
(+.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) x)
(+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))
(+.f64 (+.f64 x (+.f64 y z)) (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))))
(-.f64 (+.f64 y z) (-.f64 (*.f64 z (log.f64 t)) x))
(-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))
(-.f64 (/.f64 (*.f64 x x) (+.f64 (-.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))) (/.f64 (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (+.f64 (-.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))
(fma.f64 (+.f64 (*.f64 y (*.f64 y y)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 y y) (*.f64 z (-.f64 z y)))) (+.f64 (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))) x))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 y y) (*.f64 x (-.f64 x y)))) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (-.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 (*.f64 z (log.f64 t)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) x)
(fma.f64 (-.f64 (*.f64 y y) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 y z)) (+.f64 (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))) x))
(fma.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) x)
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 x x) (*.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) x))) (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (-.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) (-.f64 (*.f64 x x) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 x x) (*.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) x))) (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (-.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) (-.f64 (*.f64 x x) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64))))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 x x) (*.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) x))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (+.f64 (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (-.f64 (*.f64 x x) (*.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (-.f64 (*.f64 x x) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (+.f64 (-.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 x x) (*.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) x)))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (-.f64 (*.f64 x x) (*.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 x x) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64)))) (neg.f64 (+.f64 (-.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))
(/.f64 (-.f64 (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 x x)) (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) x))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (+.f64 (*.f64 x x) (*.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) x))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 x x) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (+.f64 (-.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 x x))) (neg.f64 (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) x)))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (neg.f64 (+.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))
(pow.f64 (/.f64 (+.f64 (*.f64 x x) (*.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) x))) (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (-.f64 x (+.f64 y z)) (*.f64 z (log.f64 t))) (-.f64 (*.f64 x x) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 x (*.f64 x x)) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) x)))))
(*.f64 (-.f64 (*.f64 x x) (pow.f64 (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))))
(+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)
(-.f64 (/.f64 (*.f64 x x) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x)
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b x)
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (*.f64 x x) (*.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (+.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (*.f64 x x) (*.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (neg.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 x x)) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (neg.f64 (neg.f64 (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (neg.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 x x))) (neg.f64 (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)))
(pow.f64 (/.f64 (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)))))
(*.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 (*.f64 b a) (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 b #s(literal -1/2 binary64)) (*.f64 b a))
(+.f64 (*.f64 a b) (*.f64 #s(literal -1/2 binary64) b))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) (*.f64 a b))
(fma.f64 a b (*.f64 #s(literal -1/2 binary64) b))
(fma.f64 #s(literal -1/2 binary64) b (*.f64 a b))
(fma.f64 b a (*.f64 b #s(literal -1/2 binary64)))
(fma.f64 b #s(literal -1/2 binary64) (*.f64 b a))
(/.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64)))))
(/.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64)))))
(/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))
(/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (neg.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)))) (neg.f64 (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)))) (neg.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (neg.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) (neg.f64 (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b)) (neg.f64 (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b)) (neg.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b)) (neg.f64 (+.f64 a #s(literal 1/2 binary64))))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(+.f64 a #s(literal -1/2 binary64))
(+.f64 #s(literal -1/2 binary64) a)
(-.f64 a #s(literal 1/2 binary64))
(-.f64 (/.f64 (*.f64 a (*.f64 a a)) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))) (/.f64 #s(literal 1/8 binary64) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(-.f64 (/.f64 (*.f64 a a) (+.f64 a #s(literal 1/2 binary64))) (/.f64 #s(literal 1/4 binary64) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) (+.f64 #s(literal 1/4 binary64) (-.f64 (*.f64 a a) (*.f64 a #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (neg.f64 (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (neg.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) (neg.f64 (+.f64 #s(literal 1/4 binary64) (-.f64 (*.f64 a a) (*.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (neg.f64 (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (-.f64 #s(literal 1/4 binary64) (*.f64 a a)) (-.f64 #s(literal -1/2 binary64) a))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)))) (neg.f64 (neg.f64 (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)))) (neg.f64 (neg.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) (neg.f64 (neg.f64 (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 1/4 binary64) (*.f64 a a))) (neg.f64 (-.f64 #s(literal -1/2 binary64) a)))
(pow.f64 (/.f64 (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64))))))
(*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (+.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 x y))
(+.f64 (+.f64 x y) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(+.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x)
(+.f64 (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) x) y)
(-.f64 (/.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (-.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 x y))) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 x y))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(fma.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z (+.f64 x y))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 y y) (*.f64 x (-.f64 x y)))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(fma.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 (+.f64 x y) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64)) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 x y)) (-.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (+.f64 x y)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 (+.f64 x y) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64)) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 x y)) (-.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (+.f64 x y))))))
(/.f64 (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64)) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 (+.f64 x y) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))))
(/.f64 (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64)) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (*.f64 z (+.f64 x y))))))
(/.f64 (-.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (+.f64 x y))) (-.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 x y)))
(/.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64)) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))))) (neg.f64 (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 (+.f64 x y) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64)) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))))) (neg.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (*.f64 z (+.f64 x y)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 x y))))
(/.f64 (+.f64 (pow.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal 3 binary64)) (*.f64 x (*.f64 x x))) (+.f64 (pow.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (*.f64 x x) (*.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x))))
(/.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64))) (-.f64 (+.f64 x y) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 (-.f64 (pow.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal 2 binary64)) (*.f64 x x)) (-.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x))
(/.f64 (neg.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64)) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))))) (neg.f64 (neg.f64 (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 (+.f64 x y) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (+.f64 x y))))) (neg.f64 (neg.f64 (-.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 x y)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal 3 binary64)) (*.f64 x (*.f64 x x)))) (neg.f64 (+.f64 (pow.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (*.f64 x x) (*.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 x y) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal 2 binary64)) (*.f64 x x))) (neg.f64 (-.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x)))
(pow.f64 (/.f64 (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 (+.f64 x y) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64)) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 x y)) (-.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (+.f64 x y)))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64)) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 (+.f64 x y) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))))
(*.f64 (-.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 x y))))
(+.f64 (*.f64 #s(literal 1 binary64) z) (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))))
(+.f64 (*.f64 z #s(literal 1 binary64)) (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))))
(fma.f64 #s(literal 1 binary64) z (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))))
(fma.f64 z #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))))
(/.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (+.f64 #s(literal 1 binary64) (log.f64 t)))
(/.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) z) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) z) (+.f64 #s(literal 1 binary64) (log.f64 t)))
(/.f64 (neg.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t))))))
(/.f64 (neg.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (neg.f64 (+.f64 #s(literal 1 binary64) (log.f64 t))))
(/.f64 (neg.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) z)) (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t))))))
(/.f64 (neg.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) z)) (neg.f64 (+.f64 #s(literal 1 binary64) (log.f64 t))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
(+.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 t)))
(+.f64 (-.f64 #s(literal 0 binary64) (log.f64 t)) #s(literal 1 binary64))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t))))))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (log.f64 t))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 #s(literal 1 binary64) (log.f64 t))))
(fma.f64 #s(literal -1 binary64) (log.f64 t) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 t))))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 #s(literal 1 binary64) (log.f64 t)))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 t))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t))))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 t)))))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (log.f64 t))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (-.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 t)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (+.f64 #s(literal 1 binary64) (log.f64 t)))))
(pow.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t))))))
(*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (log.f64 t))))
(log.f64 t)
(*.f64 #s(literal 1 binary64) (log.f64 t))
(*.f64 (log.f64 t) #s(literal 1 binary64))
(+.f64 (*.f64 b (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))) (*.f64 b (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(+.f64 (*.f64 b (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 b (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))
(+.f64 (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) b) (*.f64 (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))) b))
(+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) b) (*.f64 (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b)) b))
(fma.f64 b (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (*.f64 b (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(fma.f64 b (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 b (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) b (*.f64 (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))) b))
(fma.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) b (*.f64 (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b)) b))
(/.f64 (*.f64 b (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)))) (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))))))
(/.f64 (*.f64 b (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))))
(/.f64 (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) b) (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))))))
(/.f64 (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) b) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))))
(/.f64 (neg.f64 (*.f64 b (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))))) (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t))))))))
(/.f64 (neg.f64 (*.f64 b (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))))) (neg.f64 (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t))))))
(/.f64 (neg.f64 (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) b)) (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t))))))))
(/.f64 (neg.f64 (*.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) b)) (neg.f64 (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t))))))
(*.f64 b (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t))))))
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t))))) b)
(+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(+.f64 (/.f64 x b) (+.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))
(+.f64 (/.f64 x b) (-.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 z (/.f64 b (log.f64 t)))))
(+.f64 (/.f64 y b) (+.f64 (/.f64 x b) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))))
(+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))
(+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t)))))
(+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b)))
(+.f64 (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b)) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) (+.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))
(+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) (-.f64 #s(literal -1/2 binary64) (/.f64 z (/.f64 b (log.f64 t)))))
(+.f64 (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)))
(-.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t))))
(-.f64 (/.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t))))))) (/.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t))))))))
(-.f64 (/.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t))))) (/.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t))))))
(fma.f64 #s(literal 1 binary64) (/.f64 x b) (+.f64 (/.f64 y b) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(fma.f64 #s(literal 1 binary64) (/.f64 x b) (+.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))
(fma.f64 #s(literal 1 binary64) (/.f64 x b) (-.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 z (/.f64 b (log.f64 t)))))
(fma.f64 #s(literal 1 binary64) (/.f64 y b) (+.f64 (/.f64 x b) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(fma.f64 x (/.f64 #s(literal 1 binary64) b) (+.f64 (/.f64 y b) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(fma.f64 x (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))
(fma.f64 x (/.f64 #s(literal 1 binary64) b) (-.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 z (/.f64 b (log.f64 t)))))
(fma.f64 y (/.f64 #s(literal 1 binary64) b) (+.f64 (/.f64 x b) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(fma.f64 z (neg.f64 (/.f64 (log.f64 t) b)) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(fma.f64 (/.f64 (log.f64 t) b) (-.f64 #s(literal 0 binary64) z) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(fma.f64 #s(literal -1 binary64) (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(fma.f64 (+.f64 (*.f64 x b) (*.f64 y b)) (/.f64 #s(literal 1 binary64) (*.f64 b b)) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))))
(fma.f64 (-.f64 #s(literal 0 binary64) z) (/.f64 (log.f64 t) b) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(fma.f64 (-.f64 #s(literal 0 binary64) x) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) b)) (+.f64 (/.f64 y b) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(fma.f64 (-.f64 #s(literal 0 binary64) x) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) b)) (+.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))
(fma.f64 (-.f64 #s(literal 0 binary64) x) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) b)) (-.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 z (/.f64 b (log.f64 t)))))
(fma.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) b)) (+.f64 (/.f64 x b) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(fma.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)))))) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b)))
(fma.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b))))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))
(fma.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b))))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t)))))
(fma.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))) (/.f64 #s(literal 1 binary64) (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y)))) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) x (+.f64 (/.f64 y b) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) x (+.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) x (-.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 z (/.f64 b (log.f64 t)))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) y (+.f64 (/.f64 x b) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (pow.f64 (/.f64 #s(literal 1 binary64) x) #s(literal -1 binary64)) (+.f64 (/.f64 y b) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (pow.f64 (/.f64 #s(literal 1 binary64) x) #s(literal -1 binary64)) (+.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (pow.f64 (/.f64 #s(literal 1 binary64) x) #s(literal -1 binary64)) (-.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 z (/.f64 b (log.f64 t)))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (pow.f64 (/.f64 #s(literal 1 binary64) y) #s(literal -1 binary64)) (+.f64 (/.f64 x b) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(fma.f64 (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))) (/.f64 #s(literal 1 binary64) b) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(fma.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b)))
(fma.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))
(fma.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t)))))
(fma.f64 (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b)) (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 x y) b)) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))))
(fma.f64 (neg.f64 (/.f64 (log.f64 t) b)) z (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))))) (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))) (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))))) (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))) (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (-.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) (-.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) b) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))) b))
(/.f64 (-.f64 (*.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) b) (*.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 z (log.f64 t)))) (*.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) b))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (-.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)))) (neg.f64 (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b)))))
(/.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (pow.f64 (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))) #s(literal 3 binary64))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (-.f64 (pow.f64 (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))))
(/.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))) #s(literal 2 binary64))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) b) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))) (*.f64 z (log.f64 t))))) (neg.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))) b)))
(/.f64 (neg.f64 (-.f64 (*.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) b) (*.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 z (log.f64 t))))) (neg.f64 (*.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) b)))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (pow.f64 (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (-.f64 (pow.f64 (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 z (/.f64 b (log.f64 t))))))))
(pow.f64 (/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))))) (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t)))) (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t))))))))
(*.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (/.f64 z (/.f64 b (log.f64 t))))))
(+.f64 a (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))
(+.f64 #s(literal -1/2 binary64) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))))
(+.f64 (/.f64 x b) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))
(+.f64 (/.f64 y b) (+.f64 (/.f64 x b) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))
(+.f64 (+.f64 a (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))
(+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)))
(+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) #s(literal -1/2 binary64))
(+.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 x b))
(+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))
(+.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) #s(literal -1/2 binary64)) (+.f64 a (/.f64 z b)))
(+.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 x b)) (/.f64 y b))
(-.f64 (/.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (/.f64 (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))
(fma.f64 #s(literal 1 binary64) (/.f64 x b) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))
(fma.f64 #s(literal 1 binary64) (/.f64 y b) (+.f64 (/.f64 x b) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(fma.f64 x (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))
(fma.f64 y (/.f64 #s(literal 1 binary64) b) (+.f64 (/.f64 x b) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(fma.f64 (+.f64 (*.f64 x b) (*.f64 y b)) (/.f64 #s(literal 1 binary64) (*.f64 b b)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))
(fma.f64 (-.f64 #s(literal 0 binary64) x) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) b)) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))
(fma.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) b)) (+.f64 (/.f64 x b) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(fma.f64 (+.f64 (*.f64 a (*.f64 a a)) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 b (*.f64 b b)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (/.f64 (-.f64 (/.f64 z b) a) (/.f64 b z)))) (+.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))
(fma.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b))))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)))
(fma.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))) (/.f64 #s(literal 1 binary64) (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y)))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) x (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) y (+.f64 (/.f64 x b) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (pow.f64 (/.f64 #s(literal 1 binary64) x) #s(literal -1 binary64)) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (pow.f64 (/.f64 #s(literal 1 binary64) y) #s(literal -1 binary64)) (+.f64 (/.f64 x b) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(fma.f64 (-.f64 (*.f64 a a) (/.f64 (/.f64 z b) (/.f64 b z))) (/.f64 #s(literal 1 binary64) (-.f64 a (/.f64 z b))) (+.f64 #s(literal -1/2 binary64) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))
(fma.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)))
(fma.f64 (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b)) (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 x y) b)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))))
(/.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))))
(/.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (+.f64 (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))))
(/.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 x b) (*.f64 y b)) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b))))) (*.f64 (*.f64 b b) (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64)))) (*.f64 (*.f64 b b) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 x b) (*.f64 y b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64))) (*.f64 (*.f64 b b) (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64)))) (*.f64 (*.f64 b b) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b))))) (*.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))) (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64)))) (*.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b))))))
(/.f64 (+.f64 (*.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64))) (*.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))) (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64)))) (*.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b)) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b))))) (*.f64 (/.f64 (-.f64 x y) b) (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64)))) (*.f64 (/.f64 (-.f64 x y) b) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b))))))
(/.f64 (+.f64 (*.f64 (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64))) (*.f64 (/.f64 (-.f64 x y) b) (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64)))) (*.f64 (/.f64 (-.f64 x y) b) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64)) (*.f64 b b)) (*.f64 (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))) (+.f64 (*.f64 x b) (*.f64 y b)))) (*.f64 (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))) (*.f64 b b)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64)) (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y)))) (*.f64 (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))) (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))))) (*.f64 (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))) (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64)) (/.f64 (-.f64 x y) b)) (*.f64 (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))) (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b)))) (*.f64 (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))) (/.f64 (-.f64 x y) b)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64)) (*.f64 b b)) (*.f64 (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)) (+.f64 (*.f64 x b) (*.f64 y b)))) (*.f64 (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)) (*.f64 b b)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64)) (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y)))) (*.f64 (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)) (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))))) (*.f64 (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)) (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64)) (/.f64 (-.f64 x y) b)) (*.f64 (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)) (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b)))) (*.f64 (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)) (/.f64 (-.f64 x y) b)))
(/.f64 (neg.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))) (neg.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))) (neg.f64 (+.f64 (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (neg.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))
(/.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (-.f64 (*.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (/.f64 x b) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))))) #s(literal -1/8 binary64)) (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b)))) (-.f64 #s(literal 1/4 binary64) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (*.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (-.f64 (/.f64 x b) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))
(/.f64 (-.f64 (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y)))) (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b)))) #s(literal 1/4 binary64)) (-.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) #s(literal -1/2 binary64)))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 x b) (*.f64 y b)) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b))))) (*.f64 (*.f64 b b) (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64))))) (neg.f64 (*.f64 (*.f64 b b) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 x b) (*.f64 y b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64))) (*.f64 (*.f64 b b) (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64))))) (neg.f64 (*.f64 (*.f64 b b) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b))))) (*.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))) (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64))))) (neg.f64 (*.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64))) (*.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))) (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64))))) (neg.f64 (*.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (+.f64 (*.f64 (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b)) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b))))) (*.f64 (/.f64 (-.f64 x y) b) (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64))))) (neg.f64 (*.f64 (/.f64 (-.f64 x y) b) (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64))) (*.f64 (/.f64 (-.f64 x y) b) (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64))))) (neg.f64 (*.f64 (/.f64 (-.f64 x y) b) (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64)) (*.f64 b b)) (*.f64 (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))) (+.f64 (*.f64 x b) (*.f64 y b))))) (neg.f64 (*.f64 (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))) (*.f64 b b))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64)) (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y)))) (*.f64 (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))) (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b))))))) (neg.f64 (*.f64 (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))) (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b)))) #s(literal -1/8 binary64)) (/.f64 (-.f64 x y) b)) (*.f64 (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))) (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b))))) (neg.f64 (*.f64 (-.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal 1/4 binary64)) (*.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))) (/.f64 (-.f64 x y) b))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64)) (*.f64 b b)) (*.f64 (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)) (+.f64 (*.f64 x b) (*.f64 y b))))) (neg.f64 (*.f64 (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)) (*.f64 b b))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64)) (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y)))) (*.f64 (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)) (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b))))))) (neg.f64 (*.f64 (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)) (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) #s(literal -1/4 binary64)) (/.f64 (-.f64 x y) b)) (*.f64 (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)) (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b))))) (neg.f64 (*.f64 (+.f64 (+.f64 a (/.f64 z b)) #s(literal 1/2 binary64)) (/.f64 (-.f64 x y) b))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))))) (neg.f64 (neg.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))) (neg.f64 (neg.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))))
(/.f64 (neg.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))) (neg.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (-.f64 (*.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (/.f64 x b) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))))) #s(literal -1/8 binary64))) (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b)))) (-.f64 #s(literal 1/4 binary64) (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (-.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (*.f64 (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (neg.f64 (-.f64 (/.f64 x b) (+.f64 (+.f64 (/.f64 y b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))))) (neg.f64 (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b)))) #s(literal 1/4 binary64))) (neg.f64 (-.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (/.f64 z b))) #s(literal -1/2 binary64))))
(pow.f64 (/.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))))) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)))))))
(*.f64 (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b b)) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))
(+.f64 (/.f64 x b) (/.f64 y b))
(+.f64 (/.f64 y b) (/.f64 x b))
(-.f64 (/.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (-.f64 x y) b)) (/.f64 (/.f64 (/.f64 y b) (/.f64 b y)) (/.f64 (-.f64 x y) b)))
(fma.f64 #s(literal 1 binary64) (/.f64 x b) (/.f64 y b))
(fma.f64 #s(literal 1 binary64) (/.f64 y b) (/.f64 x b))
(fma.f64 x (/.f64 #s(literal 1 binary64) b) (/.f64 y b))
(fma.f64 y (/.f64 #s(literal 1 binary64) b) (/.f64 x b))
(fma.f64 (-.f64 #s(literal 0 binary64) x) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) b)) (/.f64 y b))
(fma.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) b)) (/.f64 x b))
(fma.f64 (/.f64 #s(literal 1 binary64) b) x (/.f64 y b))
(fma.f64 (/.f64 #s(literal 1 binary64) b) y (/.f64 x b))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (pow.f64 (/.f64 #s(literal 1 binary64) x) #s(literal -1 binary64)) (/.f64 y b))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (pow.f64 (/.f64 #s(literal 1 binary64) y) #s(literal -1 binary64)) (/.f64 x b))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 b b) (+.f64 (*.f64 x b) (*.f64 y b))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))) (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (-.f64 x y) b) (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 b b) (+.f64 (*.f64 x b) (*.f64 y b)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))) (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 (-.f64 x y) b) (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b)))))
(/.f64 (+.f64 (*.f64 x b) (*.f64 y b)) (*.f64 b b))
(/.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))) (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))))
(/.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))) (+.f64 (/.f64 (/.f64 y b) (/.f64 b y)) (/.f64 (*.f64 x (-.f64 x y)) (*.f64 b b))))
(/.f64 (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b)) (/.f64 (-.f64 x y) b))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 b y)) (*.f64 (/.f64 b x) #s(literal 1 binary64))) (*.f64 (/.f64 b x) (/.f64 b y)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) b) (*.f64 (/.f64 b x) y)) (*.f64 (/.f64 b x) b))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) b)) (*.f64 (/.f64 b x) (-.f64 #s(literal 0 binary64) y))) (*.f64 (/.f64 b x) (-.f64 #s(literal 0 binary64) b)))
(/.f64 (+.f64 (*.f64 x (/.f64 b y)) (*.f64 b #s(literal 1 binary64))) (*.f64 b (/.f64 b y)))
(/.f64 (+.f64 (*.f64 x (-.f64 #s(literal 0 binary64) b)) (*.f64 b (-.f64 #s(literal 0 binary64) y))) (*.f64 b (-.f64 #s(literal 0 binary64) b)))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (/.f64 b y)) (*.f64 (-.f64 #s(literal 0 binary64) b) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 b y)))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) b) (*.f64 (-.f64 #s(literal 0 binary64) b) y)) (*.f64 (-.f64 #s(literal 0 binary64) b) b))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (-.f64 #s(literal 0 binary64) b)) (*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 #s(literal 0 binary64) y))) (*.f64 b b))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 b x)) (*.f64 (/.f64 b y) #s(literal 1 binary64))) (*.f64 (/.f64 b y) (/.f64 b x)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) b) (*.f64 (/.f64 b y) x)) (*.f64 (/.f64 b y) b))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) b)) (*.f64 (/.f64 b y) (-.f64 #s(literal 0 binary64) x))) (*.f64 (/.f64 b y) (-.f64 #s(literal 0 binary64) b)))
(/.f64 (+.f64 (*.f64 y (/.f64 b x)) (*.f64 b #s(literal 1 binary64))) (*.f64 b (/.f64 b x)))
(/.f64 (+.f64 (*.f64 y (-.f64 #s(literal 0 binary64) b)) (*.f64 b (-.f64 #s(literal 0 binary64) x))) (*.f64 b (-.f64 #s(literal 0 binary64) b)))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 b x)) (*.f64 (-.f64 #s(literal 0 binary64) b) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 b x)))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) y) b) (*.f64 (-.f64 #s(literal 0 binary64) b) x)) (*.f64 (-.f64 #s(literal 0 binary64) b) b))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 #s(literal 0 binary64) b)) (*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 #s(literal 0 binary64) x))) (*.f64 b b))
(/.f64 (neg.f64 (+.f64 (*.f64 x b) (*.f64 y b))) (neg.f64 (*.f64 b b)))
(/.f64 (neg.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b))))) (neg.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y)))))
(/.f64 (neg.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b))))) (neg.f64 (+.f64 (/.f64 (/.f64 y b) (/.f64 b y)) (/.f64 (*.f64 x (-.f64 x y)) (*.f64 b b)))))
(/.f64 (neg.f64 (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b))) (neg.f64 (/.f64 (-.f64 x y) b)))
(/.f64 (/.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (*.f64 b b)) (/.f64 (-.f64 y x) b))
(/.f64 (/.f64 (+.f64 (*.f64 x b) (*.f64 y b)) b) b)
(/.f64 (neg.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 b y)) (*.f64 (/.f64 b x) #s(literal 1 binary64)))) (neg.f64 (*.f64 (/.f64 b x) (/.f64 b y))))
(/.f64 (neg.f64 (+.f64 (*.f64 #s(literal 1 binary64) b) (*.f64 (/.f64 b x) y))) (neg.f64 (*.f64 (/.f64 b x) b)))
(/.f64 (neg.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) b)) (*.f64 (/.f64 b x) (-.f64 #s(literal 0 binary64) y)))) (neg.f64 (*.f64 (/.f64 b x) (-.f64 #s(literal 0 binary64) b))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (/.f64 b y)) (*.f64 b #s(literal 1 binary64)))) (neg.f64 (*.f64 b (/.f64 b y))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (-.f64 #s(literal 0 binary64) b)) (*.f64 b (-.f64 #s(literal 0 binary64) y)))) (neg.f64 (*.f64 b (-.f64 #s(literal 0 binary64) b))))
(/.f64 (neg.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (/.f64 b y)) (*.f64 (-.f64 #s(literal 0 binary64) b) #s(literal 1 binary64)))) (neg.f64 (*.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 b y))))
(/.f64 (neg.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) b) (*.f64 (-.f64 #s(literal 0 binary64) b) y))) (neg.f64 (*.f64 (-.f64 #s(literal 0 binary64) b) b)))
(/.f64 (neg.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (-.f64 #s(literal 0 binary64) b)) (*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 #s(literal 0 binary64) y)))) (neg.f64 (*.f64 b b)))
(/.f64 (neg.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 b x)) (*.f64 (/.f64 b y) #s(literal 1 binary64)))) (neg.f64 (*.f64 (/.f64 b y) (/.f64 b x))))
(/.f64 (neg.f64 (+.f64 (*.f64 #s(literal 1 binary64) b) (*.f64 (/.f64 b y) x))) (neg.f64 (*.f64 (/.f64 b y) b)))
(/.f64 (neg.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) b)) (*.f64 (/.f64 b y) (-.f64 #s(literal 0 binary64) x)))) (neg.f64 (*.f64 (/.f64 b y) (-.f64 #s(literal 0 binary64) b))))
(/.f64 (neg.f64 (+.f64 (*.f64 y (/.f64 b x)) (*.f64 b #s(literal 1 binary64)))) (neg.f64 (*.f64 b (/.f64 b x))))
(/.f64 (neg.f64 (+.f64 (*.f64 y (-.f64 #s(literal 0 binary64) b)) (*.f64 b (-.f64 #s(literal 0 binary64) x)))) (neg.f64 (*.f64 b (-.f64 #s(literal 0 binary64) b))))
(/.f64 (neg.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) y) (/.f64 b x)) (*.f64 (-.f64 #s(literal 0 binary64) b) #s(literal 1 binary64)))) (neg.f64 (*.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 b x))))
(/.f64 (neg.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) y) b) (*.f64 (-.f64 #s(literal 0 binary64) b) x))) (neg.f64 (*.f64 (-.f64 #s(literal 0 binary64) b) b)))
(/.f64 (neg.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) y) (-.f64 #s(literal 0 binary64) b)) (*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 #s(literal 0 binary64) x)))) (neg.f64 (*.f64 b b)))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 x b) (*.f64 y b)))) (neg.f64 (neg.f64 (*.f64 b b))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))))) (neg.f64 (neg.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))))))
(/.f64 (neg.f64 (neg.f64 (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b)))) (neg.f64 (neg.f64 (/.f64 (-.f64 x y) b))))
(/.f64 (neg.f64 (/.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (*.f64 b b))) (neg.f64 (/.f64 (-.f64 y x) b)))
(/.f64 (neg.f64 (/.f64 (+.f64 (*.f64 x b) (*.f64 y b)) b)) (-.f64 #s(literal 0 binary64) b))
(pow.f64 (/.f64 (*.f64 b b) (+.f64 (*.f64 x b) (*.f64 y b))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y))) (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (-.f64 x y) b) (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 x b) (*.f64 y b)) (/.f64 #s(literal 1 binary64) (*.f64 b b)))
(*.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))) (/.f64 #s(literal 1 binary64) (+.f64 (/.f64 (/.f64 x b) (/.f64 b x)) (/.f64 (/.f64 (-.f64 y x) b) (/.f64 b y)))))
(*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))
(*.f64 (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (*.f64 b b)) (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 x y) b)))
(*.f64 z (log.f64 t))
(*.f64 (log.f64 t) z)
(+.f64 y (-.f64 z (*.f64 z (log.f64 t))))
(+.f64 z (+.f64 y (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t)))))
(+.f64 z (-.f64 y (*.f64 z (log.f64 t))))
(+.f64 (+.f64 y z) (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))))
(+.f64 (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))) (+.f64 y z))
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) y)
(-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))
(-.f64 (/.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 (*.f64 z (log.f64 t)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 (*.f64 z (log.f64 t)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(-.f64 (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))
(fma.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t)) (+.f64 y z))
(fma.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z) (+.f64 y z))
(fma.f64 #s(literal -1 binary64) (*.f64 z (log.f64 t)) (+.f64 y z))
(fma.f64 (-.f64 #s(literal 0 binary64) z) (log.f64 t) (+.f64 y z))
(fma.f64 (-.f64 #s(literal 0 binary64) (log.f64 t)) z (+.f64 y z))
(fma.f64 (+.f64 (*.f64 y (*.f64 y y)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 y y) (*.f64 z (-.f64 z y)))) (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))))
(fma.f64 (-.f64 (*.f64 y y) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 y z)) (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 (*.f64 z (log.f64 t)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (-.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 (*.f64 z (log.f64 t)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (-.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))))
(/.f64 (-.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 (*.f64 z (log.f64 t)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(/.f64 (-.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 y z) (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t)))))))
(/.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(/.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (-.f64 (+.f64 y z) (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 (*.f64 z (log.f64 t)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 y z) (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (neg.f64 (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 y z) (*.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t))))))
(/.f64 (+.f64 (*.f64 y (*.f64 y y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 y y) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 y (-.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (-.f64 (*.f64 y y) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (-.f64 y (-.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 (*.f64 z (log.f64 t)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(/.f64 (neg.f64 (+.f64 (*.f64 y (*.f64 y y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 y y) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 y (-.f64 z (*.f64 z (log.f64 t))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 y y) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)))) (neg.f64 (-.f64 y (-.f64 z (*.f64 z (log.f64 t))))))
(pow.f64 (/.f64 (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 (*.f64 z (log.f64 t)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (-.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (-.f64 (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 (*.f64 z (log.f64 t)) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(*.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))

simplify511.0ms (4%)

Memory
17.2MiB live, 893.3MiB allocated
Algorithm
1×egg-herbie
Rules
5 550×+-lowering-+.f64
5 550×+-lowering-+.f32
5 500×accelerator-lowering-fma.f32
5 500×accelerator-lowering-fma.f64
4 326×*-lowering-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
089013161
1291612923
0815412266
Stop Event
1×iter limit
1×node limit
Counts
732 → 732
Calls
Call 1
Inputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
x
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
y
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
y
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(+ x (+ y (* b (- a 1/2))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(* b (- a 1/2))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- a 1/2))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(/ 1 (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))))
(+ (* -1 (/ x (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2))) (/ 1 (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))))
(+ (* x (- (/ x (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 3)) (/ 1 (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2)))) (/ 1 (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))))
(+ (* x (- (* x (+ (* -1 (/ x (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 4))) (/ 1 (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 3)))) (/ 1 (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2)))) (/ 1 (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))))
(/ 1 x)
(/ (- (+ 1 (/ (* z (log t)) x)) (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) x)
(/ (- (+ 1 (+ (* -1 (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))) (pow x 2))) (/ (* z (log t)) x))) (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) x)
(/ (- (+ 1 (+ (/ (* z (log t)) x) (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2)) (pow x 3)))) (+ (/ y x) (+ (/ z x) (+ (/ (* b (- a 1/2)) x) (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))) (pow x 2)))))) x)
(/ 1 x)
(* -1 (/ (- (* -1 (/ (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) x)) 1) x))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))) x)) (* z (log t))) (+ y (+ z (* b (- a 1/2))))) x)) 1) x))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2)) x)) (* -1 (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))))) x)) (* z (log t))) (+ y (+ z (* b (- a 1/2))))) x)) 1) x))
(/ 1 (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))))
(+ (* -1 (/ y (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2))) (/ 1 (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))))
(+ (* y (- (/ y (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 3)) (/ 1 (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2)))) (/ 1 (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))))
(+ (* y (- (* y (+ (* -1 (/ y (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 4))) (/ 1 (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 3)))) (/ 1 (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2)))) (/ 1 (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))))
(/ 1 y)
(/ (- (+ 1 (/ (* z (log t)) y)) (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) y)
(/ (- (+ 1 (+ (* -1 (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))) (pow y 2))) (/ (* z (log t)) y))) (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) y)
(/ (- (+ 1 (+ (/ (* z (log t)) y) (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2)) (pow y 3)))) (+ (/ x y) (+ (/ z y) (+ (/ (* b (- a 1/2)) y) (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))) (pow y 2)))))) y)
(/ 1 y)
(* -1 (/ (- (* -1 (/ (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) y)) 1) y))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))) y)) (* z (log t))) (+ x (+ z (* b (- a 1/2))))) y)) 1) y))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2)) y)) (* -1 (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))))) y)) (* z (log t))) (+ x (+ z (* b (- a 1/2))))) y)) 1) y))
(/ 1 (+ x (+ y (* b (- a 1/2)))))
(+ (* z (- (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2)))) (/ 1 (+ x (+ y (* b (- a 1/2))))))
(+ (* z (- (+ (* -1 (/ (* z (* (- 1 (log t)) (- (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2))))) (+ x (+ y (* b (- a 1/2)))))) (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2))) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2)))) (/ 1 (+ x (+ y (* b (- a 1/2))))))
(+ (* z (- (+ (* z (- (/ (* z (* (pow (- 1 (log t)) 2) (- (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2))))) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ (* (- 1 (log t)) (- (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2)))) (+ x (+ y (* b (- a 1/2))))))) (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2))) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2)))) (/ 1 (+ x (+ y (* b (- a 1/2))))))
(/ 1 (* z (- 1 (log t))))
(/ (+ (* -1 (/ (+ (/ x (pow (- 1 (log t)) 2)) (+ (/ y (pow (- 1 (log t)) 2)) (/ (* b (- a 1/2)) (pow (- 1 (log t)) 2)))) z)) (/ 1 (- 1 (log t)))) z)
(/ (- (+ (/ 1 (- 1 (log t))) (/ (* (+ x (+ y (* b (- a 1/2)))) (+ (/ x (pow (- 1 (log t)) 2)) (+ (/ y (pow (- 1 (log t)) 2)) (/ (* b (- a 1/2)) (pow (- 1 (log t)) 2))))) (* (pow z 2) (- 1 (log t))))) (+ (/ x (* z (pow (- 1 (log t)) 2))) (+ (/ y (* z (pow (- 1 (log t)) 2))) (/ (* b (- a 1/2)) (* z (pow (- 1 (log t)) 2)))))) z)
(/ (- (+ (* -1 (/ (* (pow (+ x (+ y (* b (- a 1/2)))) 2) (+ (/ x (pow (- 1 (log t)) 2)) (+ (/ y (pow (- 1 (log t)) 2)) (/ (* b (- a 1/2)) (pow (- 1 (log t)) 2))))) (* (pow z 3) (pow (- 1 (log t)) 2)))) (/ 1 (- 1 (log t)))) (+ (* -1 (/ (* (+ x (+ y (* b (- a 1/2)))) (+ (/ x (pow (- 1 (log t)) 2)) (+ (/ y (pow (- 1 (log t)) 2)) (/ (* b (- a 1/2)) (pow (- 1 (log t)) 2))))) (* (pow z 2) (- 1 (log t))))) (+ (/ x (* z (pow (- 1 (log t)) 2))) (+ (/ y (* z (pow (- 1 (log t)) 2))) (/ (* b (- a 1/2)) (* z (pow (- 1 (log t)) 2))))))) z)
(/ 1 (* z (+ 1 (* -1 (log t)))))
(* -1 (/ (- (+ (/ x (* z (pow (+ 1 (* -1 (log t))) 2))) (+ (/ y (* z (pow (+ 1 (* -1 (log t))) 2))) (/ (* b (- a 1/2)) (* z (pow (+ 1 (* -1 (log t))) 2))))) (/ 1 (+ 1 (* -1 (log t))))) z))
(* -1 (/ (- (* -1 (/ (- (/ (* (+ x (+ y (* b (- a 1/2)))) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) (* z (+ 1 (* -1 (log t))))) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) z)) (/ 1 (+ 1 (* -1 (log t))))) z))
(* -1 (/ (- (* -1 (/ (- (* -1 (/ (- (/ (* (pow (+ x (+ y (* b (- a 1/2)))) 2) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) (* z (pow (+ 1 (* -1 (log t))) 2))) (/ (* (+ x (+ y (* b (- a 1/2)))) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) (+ 1 (* -1 (log t))))) z)) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) z)) (/ 1 (+ 1 (* -1 (log t))))) z))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(/ 1 (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))))
(+ (* -1 (/ (* a b) (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2))) (/ 1 (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))))
(+ (* a (- (/ (* a (pow b 2)) (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 3)) (/ b (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))))
(+ (* a (- (* a (- (* -1 (/ (* a (pow b 3)) (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 4))) (* -1 (/ (pow b 2) (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 3))))) (/ b (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))))
(/ 1 (* a b))
(/ (- (+ (/ 1/2 (* a b)) (+ (/ 1 b) (/ (* z (log t)) (* a (pow b 2))))) (+ (/ x (* a (pow b 2))) (+ (/ y (* a (pow b 2))) (/ z (* a (pow b 2)))))) a)
(/ (- (+ (* -1 (/ (* (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* (pow a 2) b))) (+ (/ 1/2 (* a b)) (+ (/ 1 b) (/ (* z (log t)) (* a (pow b 2)))))) (+ (/ x (* a (pow b 2))) (+ (/ y (* a (pow b 2))) (/ z (* a (pow b 2)))))) a)
(/ (- (+ (/ 1/2 (* a b)) (+ (/ 1 b) (+ (/ (* z (log t)) (* a (pow b 2))) (/ (* (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* (pow a 3) (pow b 2)))))) (+ (/ x (* a (pow b 2))) (+ (/ y (* a (pow b 2))) (+ (/ z (* a (pow b 2))) (/ (* (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* (pow a 2) b)))))) a)
(/ 1 (* a b))
(* -1 (/ (- (* -1 (/ (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))) a)) (/ 1 b)) a))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* a b))) (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2)))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))) a)) (/ 1 b)) a))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* a (pow b 2)))) (* -1 (/ (* (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) b))) a)) (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2)))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))) a)) (/ 1 b)) a))
(/ 1 (- (+ x (+ y z)) (* z (log t))))
(+ (* b (- (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y z)) (* z (log t)))))
(+ (* b (- (+ (* -1 (/ (* b (* (- a 1/2) (- (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2))))) (- (+ x (+ y z)) (* z (log t))))) (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y z)) (* z (log t)))))
(+ (* b (- (+ (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (* b (- (/ (* b (* (pow (- a 1/2) 2) (- (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2))))) (pow (- (+ x (+ y z)) (* z (log t))) 2)) (/ (* (- a 1/2) (- (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (- (+ x (+ y z)) (* z (log t))))))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y z)) (* z (log t)))))
(/ 1 (* b (- a 1/2)))
(/ (- (+ (/ 1 (- a 1/2)) (/ (* z (log t)) (* b (pow (- a 1/2) 2)))) (+ (/ x (* b (pow (- a 1/2) 2))) (+ (/ y (* b (pow (- a 1/2) 2))) (/ z (* b (pow (- a 1/2) 2)))))) b)
(/ (- (+ (* -1 (/ (* (- (+ x (+ y z)) (* z (log t))) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* (pow b 2) (- a 1/2)))) (+ (/ 1 (- a 1/2)) (/ (* z (log t)) (* b (pow (- a 1/2) 2))))) (+ (/ x (* b (pow (- a 1/2) 2))) (+ (/ y (* b (pow (- a 1/2) 2))) (/ z (* b (pow (- a 1/2) 2)))))) b)
(/ (- (+ (/ 1 (- a 1/2)) (+ (/ (* z (log t)) (* b (pow (- a 1/2) 2))) (/ (* (pow (- (+ x (+ y z)) (* z (log t))) 2) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* (pow b 3) (pow (- a 1/2) 2))))) (+ (/ x (* b (pow (- a 1/2) 2))) (+ (/ y (* b (pow (- a 1/2) 2))) (+ (/ z (* b (pow (- a 1/2) 2))) (/ (* (- (+ x (+ y z)) (* z (log t))) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* (pow b 2) (- a 1/2))))))) b)
(/ 1 (* b (- a 1/2)))
(* -1 (/ (- (* -1 (/ (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2))))) b)) (/ 1 (- a 1/2))) b))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* (- (+ x (+ y z)) (* z (log t))) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* b (- a 1/2)))) (/ (* z (log t)) (pow (- a 1/2) 2))) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2))))) b)) (/ 1 (- a 1/2))) b))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (- (+ x (+ y z)) (* z (log t))) 2) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* b (pow (- a 1/2) 2)))) (* -1 (/ (* (- (+ x (+ y z)) (* z (log t))) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (- a 1/2)))) b)) (/ (* z (log t)) (pow (- a 1/2) 2))) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2))))) b)) (/ 1 (- a 1/2))) b))
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
x
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
y
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
y
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(+ x (+ y (* b (- a 1/2))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(* a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(* b (- a 1/2))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- a 1/2))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(- (+ y z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
x
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
x
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(- (+ x z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
y
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(+ x y)
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(* b (- a 1/2))
(+ x (* b (- a 1/2)))
(+ x (* b (- a 1/2)))
(+ x (* b (- a 1/2)))
x
(* x (+ 1 (/ (* b (- a 1/2)) x)))
(* x (+ 1 (/ (* b (- a 1/2)) x)))
(* x (+ 1 (/ (* b (- a 1/2)) x)))
x
(* -1 (* x (- (* -1 (/ (* b (- a 1/2)) x)) 1)))
(* -1 (* x (- (* -1 (/ (* b (- a 1/2)) x)) 1)))
(* -1 (* x (- (* -1 (/ (* b (- a 1/2)) x)) 1)))
(+ x (* -1/2 b))
(+ x (+ (* -1/2 b) (* a b)))
(+ x (+ (* -1/2 b) (* a b)))
(+ x (+ (* -1/2 b) (* a b)))
(* a b)
(* a (+ b (+ (* -1/2 (/ b a)) (/ x a))))
(* a (+ b (+ (* -1/2 (/ b a)) (/ x a))))
(* a (+ b (+ (* -1/2 (/ b a)) (/ x a))))
(* a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (* -1/2 b)) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (* -1/2 b)) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (* -1/2 b)) a)))))
x
(+ x (* b (- a 1/2)))
(+ x (* b (- a 1/2)))
(+ x (* b (- a 1/2)))
(* b (- a 1/2))
(* b (- (+ a (/ x b)) 1/2))
(* b (- (+ a (/ x b)) 1/2))
(* b (- (+ a (/ x b)) 1/2))
(* b (- a 1/2))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ x b)))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ x b)))))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ x b)))))
(* -1/2 b)
(+ (* -1/2 b) (* a b))
(+ (* -1/2 b) (* a b))
(+ (* -1/2 b) (* a b))
(* a b)
(* a (+ b (* -1/2 (/ b a))))
(* a (+ b (* -1/2 (/ b a))))
(* a (+ b (* -1/2 (/ b a))))
(* a b)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
(* b (- a 1/2))
-1/2
(- a 1/2)
(- a 1/2)
(- a 1/2)
a
(* a (- 1 (* 1/2 (/ 1 a))))
(* a (- 1 (* 1/2 (/ 1 a))))
(* a (- 1 (* 1/2 (/ 1 a))))
a
(* -1 (* a (- (* 1/2 (/ 1 a)) 1)))
(* -1 (* a (- (* 1/2 (/ 1 a)) 1)))
(* -1 (* a (- (* 1/2 (/ 1 a)) 1)))
(+ x y)
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(* z (- 1 (log t)))
(* -1 (* z (+ (* -1 (- 1 (log t))) (* -1 (/ (+ x y) z)))))
(* -1 (* z (+ (* -1 (- 1 (log t))) (* -1 (/ (+ x y) z)))))
(* -1 (* z (+ (* -1 (- 1 (log t))) (* -1 (/ (+ x y) z)))))
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (* -1 (log (/ 1 t)))))))
(+ x (+ y (* z (- 1 (* -1 (log (/ 1 t)))))))
(+ x (+ y (* z (- 1 (* -1 (log (/ 1 t)))))))
(+ x (+ y (* z (- 1 (* -1 (log (/ 1 t)))))))
(+ x (+ y (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))))
(+ x (+ y (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))))
(+ x (+ y (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))))
(+ x (+ y (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))))
(+ x (* z (- 1 (log t))))
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
y
(* y (+ 1 (+ (/ x y) (/ (* z (- 1 (log t))) y))))
(* y (+ 1 (+ (/ x y) (/ (* z (- 1 (log t))) y))))
(* y (+ 1 (+ (/ x y) (/ (* z (- 1 (log t))) y))))
y
(* -1 (* y (- (* -1 (/ (+ x (* z (- 1 (log t)))) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x (* z (- 1 (log t)))) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x (* z (- 1 (log t)))) y)) 1)))
(+ y (* z (- 1 (log t))))
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
x
(* x (+ 1 (+ (/ y x) (/ (* z (- 1 (log t))) x))))
(* x (+ 1 (+ (/ y x) (/ (* z (- 1 (log t))) x))))
(* x (+ 1 (+ (/ y x) (/ (* z (- 1 (log t))) x))))
x
(* -1 (* x (- (* -1 (/ (+ y (* z (- 1 (log t)))) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y (* z (- 1 (log t)))) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y (* z (- 1 (log t)))) x)) 1)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(- 1 (log t))
(- 1 (log t))
(- 1 (log t))
(- 1 (log t))
(- 1 (* -1 (log (/ 1 t))))
(- 1 (* -1 (log (/ 1 t))))
(- 1 (* -1 (log (/ 1 t))))
(- 1 (* -1 (log (/ 1 t))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(log t)
(log t)
(log t)
(log t)
(* -1 (log (/ 1 t)))
(* -1 (log (/ 1 t)))
(* -1 (log (/ 1 t)))
(* -1 (log (/ 1 t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(+ (log -1) (* -1 (log (/ -1 t))))
(+ (log -1) (* -1 (log (/ -1 t))))
(+ (log -1) (* -1 (log (/ -1 t))))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(* b (- a 1/2))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- a 1/2))
(* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ x b)) (+ (* -1 (/ y b)) (* -1 (/ z b))))) (* -1 (/ (* z (log t)) b)))))
(* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ x b)) (+ (* -1 (/ y b)) (* -1 (/ z b))))) (* -1 (/ (* z (log t)) b)))))
(* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ x b)) (+ (* -1 (/ y b)) (* -1 (/ z b))))) (* -1 (/ (* z (log t)) b)))))
(* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
x
(* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))
(* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))
(* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))
x
(* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))
(* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))
(* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))
(* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
y
(* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))
(* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))
(* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))
y
(* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))
(* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))
(* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))
(* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(* a b)
(* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))
(* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))
(* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))
(* a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))
(* b (- (+ a (+ (/ x b) (/ y b))) 1/2))
(+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))
(+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))
(+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))
(* b (* z (- (/ 1 b) (/ (log t) b))))
(* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))
(* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))
(* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))
(* b (* z (+ (* -1 (/ (log t) b)) (/ 1 b))))
(* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))
(* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))
(* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(/ x b)
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))
(/ x b)
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))
(/ (- (+ x (+ y z)) (* z (log t))) b)
(/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)
(/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)
(/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)
(- a 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- a 1/2)
(- (+ a (* -1 (/ (- (+ (* -1 x) (+ (* -1 y) (* -1 z))) (* -1 (* z (log t)))) b))) 1/2)
(- (+ a (* -1 (/ (- (+ (* -1 x) (+ (* -1 y) (* -1 z))) (* -1 (* z (log t)))) b))) 1/2)
(- (+ a (* -1 (/ (- (+ (* -1 x) (+ (* -1 y) (* -1 z))) (* -1 (* z (log t)))) b))) 1/2)
(- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(/ y b)
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))
(/ y b)
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))
(- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
a
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))
a
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))
(- (+ a (+ (/ x b) (/ y b))) 1/2)
(- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)
(- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)
(- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)
(* z (- (/ 1 b) (/ (log t) b)))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))
(* z (+ (* -1 (/ (log t) b)) (/ 1 b)))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(- (+ a (+ (/ y b) (/ z b))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(/ x b)
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (* 1/2 (/ 1 x))))
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (* 1/2 (/ 1 x))))
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (* 1/2 (/ 1 x))))
(/ x b)
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) 1/2) x)) (/ 1 b))))
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) 1/2) x)) (/ 1 b))))
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) 1/2) x)) (/ 1 b))))
(/ (+ x (+ y z)) b)
(/ (+ x (+ y (+ z (* b (- a 1/2))))) b)
(/ (+ x (+ y (+ z (* b (- a 1/2))))) b)
(/ (+ x (+ y (+ z (* b (- a 1/2))))) b)
(- a 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(- a 1/2)
(- (+ a (* -1 (/ (+ (* -1 x) (+ (* -1 y) (* -1 z))) b))) 1/2)
(- (+ a (* -1 (/ (+ (* -1 x) (+ (* -1 y) (* -1 z))) b))) 1/2)
(- (+ a (* -1 (/ (+ (* -1 x) (+ (* -1 y) (* -1 z))) b))) 1/2)
(- (+ a (+ (/ x b) (/ z b))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(/ y b)
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (* 1/2 (/ 1 y))))
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (* 1/2 (/ 1 y))))
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (* 1/2 (/ 1 y))))
(/ y b)
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) 1/2) y)) (/ 1 b))))
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) 1/2) y)) (/ 1 b))))
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) 1/2) y)) (/ 1 b))))
(- (+ (/ x b) (+ (/ y b) (/ z b))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
a
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (* 1/2 (/ 1 a))))
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (* 1/2 (/ 1 a))))
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (* 1/2 (/ 1 a))))
a
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) 1/2) a)) 1)))
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) 1/2) a)) 1)))
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) 1/2) a)) 1)))
(- (+ a (+ (/ x b) (/ y b))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(/ z b)
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (* 1/2 (/ 1 z))))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (* 1/2 (/ 1 z))))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (* 1/2 (/ 1 z))))
(/ z b)
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (/ 1 b))))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (/ 1 b))))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (/ 1 b))))
(/ y b)
(+ (/ x b) (/ y b))
(+ (/ x b) (/ y b))
(+ (/ x b) (/ y b))
(/ x b)
(* x (+ (/ 1 b) (/ y (* b x))))
(* x (+ (/ 1 b) (/ y (* b x))))
(* x (+ (/ 1 b) (/ y (* b x))))
(/ x b)
(* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))
(* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))
(* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(* -1 (/ (+ (* -1 x) (* -1 y)) b))
(* -1 (/ (+ (* -1 x) (* -1 y)) b))
(* -1 (/ (+ (* -1 x) (* -1 y)) b))
(* -1 (/ (+ (* -1 x) (* -1 y)) b))
(/ x b)
(+ (/ x b) (/ y b))
(+ (/ x b) (/ y b))
(+ (/ x b) (/ y b))
(/ y b)
(* y (+ (/ 1 b) (/ x (* b y))))
(* y (+ (/ 1 b) (/ x (* b y))))
(* y (+ (/ 1 b) (/ x (* b y))))
(/ y b)
(* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))
(* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))
(* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* -1 (* z (log (/ 1 t))))
(* -1 (* z (log (/ 1 t))))
(* -1 (* z (log (/ 1 t))))
(* -1 (* z (log (/ 1 t))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(- z (* z (log t)))
(- (+ y z) (* z (log t)))
(- (+ y z) (* z (log t)))
(- (+ y z) (* z (log t)))
y
(* y (- (+ 1 (/ z y)) (/ (* z (log t)) y)))
(* y (- (+ 1 (/ z y)) (/ (* z (log t)) y)))
(* y (- (+ 1 (/ z y)) (/ (* z (log t)) y)))
y
(* -1 (* y (- (* -1 (/ (- z (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- z (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- z (* z (log t))) y)) 1)))
y
(+ y (* z (- 1 (log t))))
(+ y (* z (- 1 (log t))))
(+ y (* z (- 1 (log t))))
(* z (- 1 (log t)))
(* z (- (+ 1 (/ y z)) (log t)))
(* z (- (+ 1 (/ y z)) (log t)))
(* z (- (+ 1 (/ y z)) (log t)))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ y z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ y z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ y z)) (+ 1 (* -1 (log t))))))
(- (+ y z) (* z (log t)))
(- (+ y z) (* z (log t)))
(- (+ y z) (* z (log t)))
(- (+ y z) (* z (log t)))
(- (+ y z) (* -1 (* z (log (/ 1 t)))))
(- (+ y z) (* -1 (* z (log (/ 1 t)))))
(- (+ y z) (* -1 (* z (log (/ 1 t)))))
(- (+ y z) (* -1 (* z (log (/ 1 t)))))
(- (+ y z) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ y z) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ y z) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ y z) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
Outputs
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 z x) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))) (-.f64 (/.f64 y x) (/.f64 (*.f64 z (log.f64 t)) x)))))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 z x) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))) (-.f64 (/.f64 y x) (/.f64 (*.f64 z (log.f64 t)) x)))))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 z x) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))) (-.f64 (/.f64 y x) (/.f64 (*.f64 z (log.f64 t)) x)))))
x
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 #s(literal 0 binary64) x)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 #s(literal 0 binary64) x)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 #s(literal 0 binary64) x)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
y
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 (/.f64 x y) (+.f64 (/.f64 z y) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) y))) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 (/.f64 x y) (+.f64 (/.f64 z y) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) y))) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 (/.f64 x y) (+.f64 (/.f64 z y) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) y))) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) y))))
y
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 #s(literal 0 binary64) y)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) y))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 #s(literal 0 binary64) y)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) y))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 #s(literal 0 binary64) y)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) y))
(+ x (+ y (* b (- a 1/2))))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(*.f64 z (+.f64 (+.f64 (/.f64 x z) (+.f64 (/.f64 y z) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) z))) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(*.f64 z (+.f64 (+.f64 (/.f64 x z) (+.f64 (/.f64 y z) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) z))) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(*.f64 z (+.f64 (+.f64 (/.f64 x z) (+.f64 (/.f64 y z) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) z))) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (+ 1 (* -1 (log t))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (-.f64 #s(literal 0 binary64) z)) (+.f64 (log.f64 t) #s(literal -1 binary64))) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (-.f64 #s(literal 0 binary64) z)) (+.f64 (log.f64 t) #s(literal -1 binary64))) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (-.f64 #s(literal 0 binary64) z)) (+.f64 (log.f64 t) #s(literal -1 binary64))) (-.f64 #s(literal 0 binary64) z))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(-.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(-.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(-.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(-.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t)))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (+.f64 (+.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 b (/.f64 (*.f64 z (log.f64 t)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (+.f64 (+.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 b (/.f64 (*.f64 z (log.f64 t)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (+.f64 (+.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 b (/.f64 (*.f64 z (log.f64 t)) a))))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) a)) (neg.f64 a))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 (+.f64 (neg.f64 a) #s(literal 1/2 binary64)) (/.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) b)))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 (+.f64 (neg.f64 a) #s(literal 1/2 binary64)) (/.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) b)))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 (+.f64 (neg.f64 a) #s(literal 1/2 binary64)) (/.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) b)))
(/ 1 (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))))
(/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(+ (* -1 (/ x (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2))) (/ 1 (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) (/.f64 x (pow.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))))
(+ (* x (- (/ x (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 3)) (/ 1 (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2)))) (/ 1 (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) (*.f64 x (+.f64 (/.f64 x (pow.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 3 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))))))
(+ (* x (- (* x (+ (* -1 (/ x (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 4))) (/ 1 (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 3)))) (/ 1 (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2)))) (/ 1 (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) (*.f64 x (+.f64 (*.f64 x (-.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 3 binary64))) (/.f64 x (pow.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 4 binary64))))) (/.f64 #s(literal -1 binary64) (pow.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))))))
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(/ (- (+ 1 (/ (* z (log t)) x)) (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) x)
(/.f64 (+.f64 #s(literal 1 binary64) (-.f64 (-.f64 (/.f64 (*.f64 z (log.f64 t)) x) (/.f64 y x)) (+.f64 (/.f64 z x) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))) x)
(/ (- (+ 1 (+ (* -1 (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))) (pow x 2))) (/ (* z (log t)) x))) (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) x)
(/.f64 (+.f64 #s(literal 1 binary64) (-.f64 (-.f64 (/.f64 (*.f64 z (log.f64 t)) x) (/.f64 (*.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 (*.f64 z (log.f64 t)) (+.f64 y (+.f64 z (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (*.f64 x x))) (+.f64 (/.f64 y x) (+.f64 (/.f64 z x) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x)))))) x)
(/ (- (+ 1 (+ (/ (* z (log t)) x) (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2)) (pow x 3)))) (+ (/ y x) (+ (/ z x) (+ (/ (* b (- a 1/2)) x) (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))) (pow x 2)))))) x)
(/.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) x)) (-.f64 (*.f64 (/.f64 (pow.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64)) x) (/.f64 (-.f64 (*.f64 z (log.f64 t)) (+.f64 y (+.f64 z (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (*.f64 x x))) (+.f64 (+.f64 (/.f64 y x) (+.f64 (/.f64 z x) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x)))) (/.f64 (*.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 (*.f64 z (log.f64 t)) (+.f64 y (+.f64 z (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (*.f64 x x))))) x)
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(* -1 (/ (- (* -1 (/ (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) x)) 1) x))
(/.f64 (+.f64 (/.f64 (-.f64 (*.f64 z (log.f64 t)) (+.f64 y (+.f64 z (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (-.f64 #s(literal 0 binary64) x)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))) x)) (* z (log t))) (+ y (+ z (* b (- a 1/2))))) x)) 1) x))
(/.f64 (+.f64 (/.f64 (-.f64 (-.f64 (*.f64 z (log.f64 t)) (/.f64 (*.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 (*.f64 z (log.f64 t)) (+.f64 y (+.f64 z (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) x)) (+.f64 y (+.f64 z (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (-.f64 #s(literal 0 binary64) x)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (pow (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) 2)) x)) (* -1 (* (- (* z (log t)) (+ y (+ z (* b (- a 1/2))))) (- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))))) x)) (* z (log t))) (+ y (+ z (* b (- a 1/2))))) x)) 1) x))
(/.f64 (+.f64 (*.f64 (/.f64 (-.f64 (-.f64 (*.f64 z (log.f64 t)) (/.f64 (neg.f64 (*.f64 (-.f64 (*.f64 z (log.f64 t)) (+.f64 y (+.f64 z (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (-.f64 (/.f64 (pow.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64)) x) (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))))) x)) (+.f64 y (+.f64 z (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (-.f64 #s(literal 0 binary64) x)) #s(literal -1 binary64)) #s(literal 1 binary64)) x)
(/ 1 (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))))
(/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(+ (* -1 (/ y (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2))) (/ 1 (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) (/.f64 y (pow.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))))
(+ (* y (- (/ y (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 3)) (/ 1 (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2)))) (/ 1 (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) (*.f64 y (-.f64 (/.f64 y (pow.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))))))
(+ (* y (- (* y (+ (* -1 (/ y (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 4))) (/ 1 (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 3)))) (/ 1 (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2)))) (/ 1 (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) (*.f64 y (+.f64 (*.f64 y (-.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 3 binary64))) (/.f64 y (pow.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 4 binary64))))) (/.f64 #s(literal -1 binary64) (pow.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))))))
(/ 1 y)
(/.f64 #s(literal 1 binary64) y)
(/ (- (+ 1 (/ (* z (log t)) y)) (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) y)
(/.f64 (+.f64 (/.f64 (*.f64 z (log.f64 t)) y) (-.f64 #s(literal 1 binary64) (+.f64 (/.f64 x y) (+.f64 (/.f64 z y) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) y))))) y)
(/ (- (+ 1 (+ (* -1 (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))) (pow y 2))) (/ (* z (log t)) y))) (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) y)
(/.f64 (+.f64 (-.f64 (/.f64 (*.f64 z (log.f64 t)) y) (/.f64 (*.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 (-.f64 (-.f64 (*.f64 z (log.f64 t)) x) z) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (*.f64 y y))) (-.f64 #s(literal 1 binary64) (+.f64 (/.f64 x y) (+.f64 (/.f64 z y) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) y))))) y)
(/ (- (+ 1 (+ (/ (* z (log t)) y) (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2)) (pow y 3)))) (+ (/ x y) (+ (/ z y) (+ (/ (* b (- a 1/2)) y) (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))) (pow y 2)))))) y)
(/.f64 (-.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) y)) (/.f64 (*.f64 (pow.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64)) (-.f64 (-.f64 (-.f64 (*.f64 z (log.f64 t)) x) z) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (*.f64 y (*.f64 y y)))) (+.f64 (+.f64 (/.f64 x y) (+.f64 (/.f64 z y) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) y))) (/.f64 (*.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 (-.f64 (-.f64 (*.f64 z (log.f64 t)) x) z) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (*.f64 y y)))) y)
(/ 1 y)
(/.f64 #s(literal 1 binary64) y)
(* -1 (/ (- (* -1 (/ (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) y)) 1) y))
(/.f64 (+.f64 (/.f64 (-.f64 (-.f64 (-.f64 (*.f64 z (log.f64 t)) x) z) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 #s(literal 0 binary64) y)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) y))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))) y)) (* z (log t))) (+ x (+ z (* b (- a 1/2))))) y)) 1) y))
(/.f64 (+.f64 (/.f64 (-.f64 (-.f64 (*.f64 z (log.f64 t)) (*.f64 (-.f64 (-.f64 (-.f64 (*.f64 z (log.f64 t)) x) z) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) y))) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) (-.f64 #s(literal 0 binary64) y)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) y))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (pow (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) 2)) y)) (* -1 (* (- (* z (log t)) (+ x (+ z (* b (- a 1/2))))) (- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))))) y)) (* z (log t))) (+ x (+ z (* b (- a 1/2))))) y)) 1) y))
(/.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (-.f64 (-.f64 (*.f64 z (log.f64 t)) (/.f64 (neg.f64 (*.f64 (-.f64 (-.f64 (-.f64 (*.f64 z (log.f64 t)) x) z) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (/.f64 (pow.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64)) y) (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))))) y)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) y)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) y))
(/ 1 (+ x (+ y (* b (- a 1/2)))))
(/.f64 #s(literal 1 binary64) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)))
(+ (* z (- (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2)))) (/ 1 (+ x (+ y (* b (- a 1/2))))))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x))) (*.f64 z (+.f64 (/.f64 (log.f64 t) (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)))) (/.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)))))))
(+ (* z (- (+ (* -1 (/ (* z (* (- 1 (log t)) (- (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2))))) (+ x (+ y (* b (- a 1/2)))))) (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2))) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2)))) (/ 1 (+ x (+ y (* b (- a 1/2))))))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x))) (*.f64 z (+.f64 (/.f64 (log.f64 t) (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)))) (+.f64 (*.f64 z (*.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 (/.f64 (log.f64 t) (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)))) (/.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x))))) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x))))) (/.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x))))))))
(+ (* z (- (+ (* z (- (/ (* z (* (pow (- 1 (log t)) 2) (- (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2))))) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ (* (- 1 (log t)) (- (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2)) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2)))) (+ x (+ y (* b (- a 1/2))))))) (/ (log t) (pow (+ x (+ y (* b (- a 1/2)))) 2))) (/ 1 (pow (+ x (+ y (* b (- a 1/2)))) 2)))) (/ 1 (+ x (+ y (* b (- a 1/2))))))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x))) (*.f64 z (+.f64 (*.f64 z (+.f64 (/.f64 (*.f64 z (*.f64 (+.f64 (/.f64 (log.f64 t) (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)))) (/.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x))))) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64)))) (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)))) (*.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 (/.f64 (log.f64 t) (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)))) (/.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x))))) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)))))) (+.f64 (/.f64 (log.f64 t) (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)))) (/.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x))))))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ (+ (* -1 (/ (+ (/ x (pow (- 1 (log t)) 2)) (+ (/ y (pow (- 1 (log t)) 2)) (/ (* b (- a 1/2)) (pow (- 1 (log t)) 2)))) z)) (/ 1 (- 1 (log t)))) z)
(/.f64 (-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) (/.f64 (+.f64 (/.f64 y (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (/.f64 x (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))))) z)) z)
(/ (- (+ (/ 1 (- 1 (log t))) (/ (* (+ x (+ y (* b (- a 1/2)))) (+ (/ x (pow (- 1 (log t)) 2)) (+ (/ y (pow (- 1 (log t)) 2)) (/ (* b (- a 1/2)) (pow (- 1 (log t)) 2))))) (* (pow z 2) (- 1 (log t))))) (+ (/ x (* z (pow (- 1 (log t)) 2))) (+ (/ y (* z (pow (- 1 (log t)) 2))) (/ (* b (- a 1/2)) (* z (pow (- 1 (log t)) 2)))))) z)
(/.f64 (+.f64 (/.f64 (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (/.f64 y (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (/.f64 x (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64)))))) (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (*.f64 z z))) (-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 (/.f64 (/.f64 x z) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (+.f64 (/.f64 (/.f64 y z) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (/.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) z) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))))))) z)
(/ (- (+ (* -1 (/ (* (pow (+ x (+ y (* b (- a 1/2)))) 2) (+ (/ x (pow (- 1 (log t)) 2)) (+ (/ y (pow (- 1 (log t)) 2)) (/ (* b (- a 1/2)) (pow (- 1 (log t)) 2))))) (* (pow z 3) (pow (- 1 (log t)) 2)))) (/ 1 (- 1 (log t)))) (+ (* -1 (/ (* (+ x (+ y (* b (- a 1/2)))) (+ (/ x (pow (- 1 (log t)) 2)) (+ (/ y (pow (- 1 (log t)) 2)) (/ (* b (- a 1/2)) (pow (- 1 (log t)) 2))))) (* (pow z 2) (- 1 (log t))))) (+ (/ x (* z (pow (- 1 (log t)) 2))) (+ (/ y (* z (pow (- 1 (log t)) 2))) (/ (* b (- a 1/2)) (* z (pow (- 1 (log t)) 2))))))) z)
(/.f64 (-.f64 (-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) (/.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x))) (+.f64 (/.f64 y (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (/.f64 x (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64)))))) (*.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z z))))) (+.f64 (+.f64 (/.f64 (/.f64 x z) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (+.f64 (/.f64 (/.f64 y z) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (/.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) z) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))))) (/.f64 (/.f64 (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (/.f64 y (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (/.f64 x (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64)))))) (*.f64 z z)) (+.f64 (log.f64 t) #s(literal -1 binary64))))) z)
(/ 1 (* z (+ 1 (* -1 (log t)))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* -1 (/ (- (+ (/ x (* z (pow (+ 1 (* -1 (log t))) 2))) (+ (/ y (* z (pow (+ 1 (* -1 (log t))) 2))) (/ (* b (- a 1/2)) (* z (pow (+ 1 (* -1 (log t))) 2))))) (/ 1 (+ 1 (* -1 (log t))))) z))
(/.f64 (+.f64 (/.f64 (/.f64 x z) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (+.f64 (+.f64 (/.f64 (/.f64 y z) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (/.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) z) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 (log.f64 t) #s(literal -1 binary64))))) (-.f64 #s(literal 0 binary64) z))
(* -1 (/ (- (* -1 (/ (- (/ (* (+ x (+ y (* b (- a 1/2)))) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) (* z (+ 1 (* -1 (log t))))) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) z)) (/ 1 (+ 1 (* -1 (log t))))) z))
(/.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (-.f64 (/.f64 (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (/.f64 y (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (/.f64 x (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64)))))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (+.f64 (/.f64 y (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (/.f64 x (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64)))))) z)) (/.f64 #s(literal 1 binary64) (+.f64 (log.f64 t) #s(literal -1 binary64)))) (-.f64 #s(literal 0 binary64) z))
(* -1 (/ (- (* -1 (/ (- (* -1 (/ (- (/ (* (pow (+ x (+ y (* b (- a 1/2)))) 2) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) (* z (pow (+ 1 (* -1 (log t))) 2))) (/ (* (+ x (+ y (* b (- a 1/2)))) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) (+ 1 (* -1 (log t))))) z)) (+ (/ x (pow (+ 1 (* -1 (log t))) 2)) (+ (/ y (pow (+ 1 (* -1 (log t))) 2)) (/ (* b (- a 1/2)) (pow (+ 1 (* -1 (log t))) 2))))) z)) (/ 1 (+ 1 (* -1 (log t))))) z))
(-.f64 #s(literal 0 binary64) (/.f64 (+.f64 (/.f64 (-.f64 (/.f64 (+.f64 (/.f64 (*.f64 (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x))) (+.f64 (/.f64 y (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (/.f64 x (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64)))))) (*.f64 z (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64)))) (/.f64 (*.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (+.f64 (/.f64 y (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (/.f64 x (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64)))))) (+.f64 (log.f64 t) #s(literal -1 binary64)))) (-.f64 #s(literal 0 binary64) z)) (+.f64 (/.f64 y (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64))) (/.f64 x (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 2 binary64)))))) (-.f64 #s(literal 0 binary64) z)) (/.f64 #s(literal 1 binary64) (+.f64 (log.f64 t) #s(literal -1 binary64)))) z))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))))
(/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))))
(/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))))
(/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))))
(/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t))))))
(/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t))))))
(/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t))))))
(/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t))))))
(/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(/.f64 #s(literal 1 binary64) (-.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(/.f64 #s(literal 1 binary64) (-.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(/.f64 #s(literal 1 binary64) (-.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(/ 1 (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(/.f64 #s(literal 1 binary64) (-.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(/ 1 (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))))
(/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))))
(+ (* -1 (/ (* a b) (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2))) (/ 1 (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t)))))) (/.f64 (*.f64 b a) (pow.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) #s(literal 2 binary64))))
(+ (* a (- (/ (* a (pow b 2)) (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 3)) (/ b (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t)))))) (*.f64 a (-.f64 (/.f64 (*.f64 a (*.f64 b b)) (pow.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) #s(literal 3 binary64))) (/.f64 b (pow.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) #s(literal 2 binary64))))))
(+ (* a (- (* a (- (* -1 (/ (* a (pow b 3)) (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 4))) (* -1 (/ (pow b 2) (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 3))))) (/ b (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t)))))) (*.f64 a (-.f64 (*.f64 a (+.f64 (/.f64 (*.f64 #s(literal -1 binary64) (*.f64 a (*.f64 b (*.f64 b b)))) (pow.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) #s(literal 4 binary64))) (/.f64 (*.f64 b b) (pow.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) #s(literal 3 binary64))))) (/.f64 b (pow.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) #s(literal 2 binary64))))))
(/ 1 (* a b))
(/.f64 #s(literal 1 binary64) (*.f64 b a))
(/ (- (+ (/ 1/2 (* a b)) (+ (/ 1 b) (/ (* z (log t)) (* a (pow b 2))))) (+ (/ x (* a (pow b 2))) (+ (/ y (* a (pow b 2))) (/ z (* a (pow b 2)))))) a)
(/.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (*.f64 z (log.f64 t)) (*.f64 a (*.f64 b b)))) (-.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 b a)) (+.f64 (/.f64 x (*.f64 a (*.f64 b b))) (+.f64 (/.f64 y (*.f64 a (*.f64 b b))) (/.f64 z (*.f64 a (*.f64 b b))))))) a)
(/ (- (+ (* -1 (/ (* (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* (pow a 2) b))) (+ (/ 1/2 (* a b)) (+ (/ 1 b) (/ (* z (log t)) (* a (pow b 2)))))) (+ (/ x (* a (pow b 2))) (+ (/ y (* a (pow b 2))) (/ z (* a (pow b 2)))))) a)
(/.f64 (-.f64 (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 b a)) (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (*.f64 z (log.f64 t)) (*.f64 a (*.f64 b b))))) (/.f64 (*.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) b) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b b))) (+.f64 (/.f64 x (*.f64 b b)) (+.f64 (/.f64 y (*.f64 b b)) (/.f64 z (*.f64 b b)))))) (*.f64 b (*.f64 a a)))) (+.f64 (/.f64 x (*.f64 a (*.f64 b b))) (+.f64 (/.f64 y (*.f64 a (*.f64 b b))) (/.f64 z (*.f64 a (*.f64 b b)))))) a)
(/ (- (+ (/ 1/2 (* a b)) (+ (/ 1 b) (+ (/ (* z (log t)) (* a (pow b 2))) (/ (* (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* (pow a 3) (pow b 2)))))) (+ (/ x (* a (pow b 2))) (+ (/ y (* a (pow b 2))) (+ (/ z (* a (pow b 2))) (/ (* (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* (pow a 2) b)))))) a)
(/.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (/.f64 (*.f64 z (log.f64 t)) (*.f64 a (*.f64 b b))) (/.f64 (*.f64 (pow.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) #s(literal 2 binary64)) (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) b) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b b))) (+.f64 (/.f64 x (*.f64 b b)) (+.f64 (/.f64 y (*.f64 b b)) (/.f64 z (*.f64 b b)))))) (*.f64 (*.f64 b b) (*.f64 a (*.f64 a a)))))) (-.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 b a)) (+.f64 (+.f64 (/.f64 x (*.f64 a (*.f64 b b))) (+.f64 (/.f64 y (*.f64 a (*.f64 b b))) (/.f64 z (*.f64 a (*.f64 b b))))) (/.f64 (*.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) b) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b b))) (+.f64 (/.f64 x (*.f64 b b)) (+.f64 (/.f64 y (*.f64 b b)) (/.f64 z (*.f64 b b)))))) (*.f64 b (*.f64 a a)))))) a)
(/ 1 (* a b))
(/.f64 #s(literal 1 binary64) (*.f64 b a))
(* -1 (/ (- (* -1 (/ (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))) a)) (/ 1 b)) a))
(/.f64 (+.f64 (/.f64 (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) b) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b b))) (+.f64 (/.f64 x (*.f64 b b)) (+.f64 (/.f64 y (*.f64 b b)) (/.f64 z (*.f64 b b))))) (neg.f64 a)) (/.f64 #s(literal -1 binary64) b)) (neg.f64 a))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* a b))) (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2)))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))) a)) (/ 1 b)) a))
(/.f64 (+.f64 (/.f64 (-.f64 (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) b) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b b))) (*.f64 (/.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) a) (/.f64 (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) b) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b b))) (+.f64 (/.f64 x (*.f64 b b)) (+.f64 (/.f64 y (*.f64 b b)) (/.f64 z (*.f64 b b))))) b))) (+.f64 (/.f64 x (*.f64 b b)) (+.f64 (/.f64 y (*.f64 b b)) (/.f64 z (*.f64 b b))))) (neg.f64 a)) (/.f64 #s(literal -1 binary64) b)) (neg.f64 a))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) 2) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) (* a (pow b 2)))) (* -1 (/ (* (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) (- (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) b))) a)) (+ (* 1/2 (/ 1 b)) (/ (* z (log t)) (pow b 2)))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))) a)) (/ 1 b)) a))
(/.f64 (+.f64 (/.f64 (-.f64 (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) b) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b b))) (/.f64 (+.f64 (/.f64 (*.f64 (pow.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) #s(literal 2 binary64)) (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) b) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b b))) (+.f64 (/.f64 x (*.f64 b b)) (+.f64 (/.f64 y (*.f64 b b)) (/.f64 z (*.f64 b b)))))) (neg.f64 (*.f64 a (*.f64 b b)))) (/.f64 (*.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) (-.f64 (+.f64 (/.f64 #s(literal 1/2 binary64) b) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b b))) (+.f64 (/.f64 x (*.f64 b b)) (+.f64 (/.f64 y (*.f64 b b)) (/.f64 z (*.f64 b b)))))) b)) a)) (+.f64 (/.f64 x (*.f64 b b)) (+.f64 (/.f64 y (*.f64 b b)) (/.f64 z (*.f64 b b))))) (neg.f64 a)) (/.f64 #s(literal -1 binary64) b)) (neg.f64 a))
(/ 1 (- (+ x (+ y z)) (* z (log t))))
(/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(+ (* b (- (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y z)) (* z (log t)))))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) (*.f64 b (-.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))) (/.f64 a (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))))))
(+ (* b (- (+ (* -1 (/ (* b (* (- a 1/2) (- (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2))))) (- (+ x (+ y z)) (* z (log t))))) (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y z)) (* z (log t)))))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) (*.f64 b (-.f64 (-.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))) (/.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))) (/.f64 a (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))))) (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))) (/.f64 a (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))))))
(+ (* b (- (+ (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (* b (- (/ (* b (* (pow (- a 1/2) 2) (- (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2))))) (pow (- (+ x (+ y z)) (* z (log t))) 2)) (/ (* (- a 1/2) (- (* 1/2 (/ 1 (pow (- (+ x (+ y z)) (* z (log t))) 2))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (- (+ x (+ y z)) (* z (log t))))))) (/ a (pow (- (+ x (+ y z)) (* z (log t))) 2)))) (/ 1 (- (+ x (+ y z)) (* z (log t)))))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) (*.f64 b (+.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))) (-.f64 (*.f64 b (-.f64 (/.f64 (*.f64 b (*.f64 (-.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))) (/.f64 a (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))) (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))) (/.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) (-.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))) (/.f64 a (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64))))) (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))))) (/.f64 a (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64)))))))
(/ 1 (* b (- a 1/2)))
(/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(/ (- (+ (/ 1 (- a 1/2)) (/ (* z (log t)) (* b (pow (- a 1/2) 2)))) (+ (/ x (* b (pow (- a 1/2) 2))) (+ (/ y (* b (pow (- a 1/2) 2))) (/ z (* b (pow (- a 1/2) 2)))))) b)
(/.f64 (+.f64 (/.f64 (/.f64 (*.f64 z (log.f64 t)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64))) (+.f64 (/.f64 (/.f64 x b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (+.f64 (/.f64 (/.f64 y b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (/.f64 z b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))))))) b)
(/ (- (+ (* -1 (/ (* (- (+ x (+ y z)) (* z (log t))) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* (pow b 2) (- a 1/2)))) (+ (/ 1 (- a 1/2)) (/ (* z (log t)) (* b (pow (- a 1/2) 2))))) (+ (/ x (* b (pow (- a 1/2) 2))) (+ (/ y (* b (pow (- a 1/2) 2))) (/ z (* b (pow (- a 1/2) 2)))))) b)
(/.f64 (-.f64 (-.f64 (+.f64 (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64))) (/.f64 (/.f64 (*.f64 z (log.f64 t)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))) (/.f64 (*.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 (-.f64 (/.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 x (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))) (+.f64 (/.f64 y (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 z (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 b b)))) (+.f64 (/.f64 (/.f64 x b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (+.f64 (/.f64 (/.f64 y b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (/.f64 z b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))))) b)
(/ (- (+ (/ 1 (- a 1/2)) (+ (/ (* z (log t)) (* b (pow (- a 1/2) 2))) (/ (* (pow (- (+ x (+ y z)) (* z (log t))) 2) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* (pow b 3) (pow (- a 1/2) 2))))) (+ (/ x (* b (pow (- a 1/2) 2))) (+ (/ y (* b (pow (- a 1/2) 2))) (+ (/ z (* b (pow (- a 1/2) 2))) (/ (* (- (+ x (+ y z)) (* z (log t))) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* (pow b 2) (- a 1/2))))))) b)
(/.f64 (-.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64))) (/.f64 (/.f64 (*.f64 z (log.f64 t)) b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))) (/.f64 (*.f64 (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64)) (-.f64 (-.f64 (/.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 x (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))) (+.f64 (/.f64 y (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 z (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))))) (*.f64 (*.f64 b (*.f64 b b)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (/.f64 (/.f64 x b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (+.f64 (/.f64 (/.f64 y b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (+.f64 (/.f64 (/.f64 z b) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (*.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 (-.f64 (/.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 x (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))) (+.f64 (/.f64 y (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 z (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 b b))))))) b)
(/ 1 (* b (- a 1/2)))
(/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(* -1 (/ (- (* -1 (/ (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2))))) b)) (/ 1 (- a 1/2))) b))
(/.f64 (+.f64 (/.f64 (-.f64 (-.f64 (/.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 x (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))) (+.f64 (/.f64 y (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 z (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))))) (-.f64 #s(literal 0 binary64) b)) (/.f64 #s(literal -1 binary64) (+.f64 a #s(literal -1/2 binary64)))) (-.f64 #s(literal 0 binary64) b))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* (- (+ x (+ y z)) (* z (log t))) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* b (- a 1/2)))) (/ (* z (log t)) (pow (- a 1/2) 2))) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2))))) b)) (/ 1 (- a 1/2))) b))
(/.f64 (+.f64 (/.f64 (-.f64 (-.f64 (/.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (*.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 (-.f64 (/.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 x (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))) (+.f64 (/.f64 y (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 z (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (+.f64 (/.f64 x (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (+.f64 (/.f64 y (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 z (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))))) (-.f64 #s(literal 0 binary64) b)) (/.f64 #s(literal -1 binary64) (+.f64 a #s(literal -1/2 binary64)))) (-.f64 #s(literal 0 binary64) b))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (- (+ x (+ y z)) (* z (log t))) 2) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (* b (pow (- a 1/2) 2)))) (* -1 (/ (* (- (+ x (+ y z)) (* z (log t))) (- (/ (* z (log t)) (pow (- a 1/2) 2)) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2)))))) (- a 1/2)))) b)) (/ (* z (log t)) (pow (- a 1/2) 2))) (+ (/ x (pow (- a 1/2) 2)) (+ (/ y (pow (- a 1/2) 2)) (/ z (pow (- a 1/2) 2))))) b)) (/ 1 (- a 1/2))) b))
(/.f64 (+.f64 (/.f64 (-.f64 (-.f64 (/.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (+.f64 (/.f64 (*.f64 (pow.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) #s(literal 2 binary64)) (-.f64 (-.f64 (/.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 x (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))) (+.f64 (/.f64 y (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 z (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (*.f64 b (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 (*.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 (-.f64 (/.f64 (*.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 x (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))) (+.f64 (/.f64 y (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 z (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 a #s(literal -1/2 binary64)))) b)) (+.f64 (/.f64 x (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (+.f64 (/.f64 y (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 z (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))))) (-.f64 #s(literal 0 binary64) b)) (/.f64 #s(literal -1 binary64) (+.f64 a #s(literal -1/2 binary64)))) (-.f64 #s(literal 0 binary64) b))
(- (+ y (+ z (* b (- a 1/2)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
x
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 z x) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))) (-.f64 (/.f64 y x) (/.f64 (*.f64 z (log.f64 t)) x)))))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 z x) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))) (-.f64 (/.f64 y x) (/.f64 (*.f64 z (log.f64 t)) x)))))
(* x (- (+ 1 (+ (/ y x) (+ (/ z x) (/ (* b (- a 1/2)) x)))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 z x) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))) (-.f64 (/.f64 y x) (/.f64 (*.f64 z (log.f64 t)) x)))))
x
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 #s(literal 0 binary64) x)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 #s(literal 0 binary64) x)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* b (- a 1/2)))) (* z (log t))) x)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 #s(literal 0 binary64) x)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(- (+ x (+ z (* b (- a 1/2)))) (* z (log t)))
(+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
y
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 (/.f64 x y) (+.f64 (/.f64 z y) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) y))) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 (/.f64 x y) (+.f64 (/.f64 z y) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) y))) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (/ x y) (+ (/ z y) (/ (* b (- a 1/2)) y)))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 (/.f64 x y) (+.f64 (/.f64 z y) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) y))) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) y))))
y
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 #s(literal 0 binary64) y)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) y))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 #s(literal 0 binary64) y)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) y))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* b (- a 1/2)))) (* z (log t))) y)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) (-.f64 #s(literal 0 binary64) y)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) y))
(+ x (+ y (* b (- a 1/2))))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(+ x (+ y (+ (* b (- a 1/2)) (* z (- 1 (log t))))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(*.f64 z (+.f64 (+.f64 (/.f64 x z) (+.f64 (/.f64 y z) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) z))) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(*.f64 z (+.f64 (+.f64 (/.f64 x z) (+.f64 (/.f64 y z) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) z))) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- (+ 1 (+ (/ x z) (+ (/ y z) (/ (* b (- a 1/2)) z)))) (log t)))
(*.f64 z (+.f64 (+.f64 (/.f64 x z) (+.f64 (/.f64 y z) (/.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) z))) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (+ 1 (* -1 (log t))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (-.f64 #s(literal 0 binary64) z)) (+.f64 (log.f64 t) #s(literal -1 binary64))) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (-.f64 #s(literal 0 binary64) z)) (+.f64 (log.f64 t) #s(literal -1 binary64))) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* b (- a 1/2)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 (+.f64 (/.f64 (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 y x)) (-.f64 #s(literal 0 binary64) z)) (+.f64 (log.f64 t) #s(literal -1 binary64))) (-.f64 #s(literal 0 binary64) z))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(-.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(-.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(-.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(-.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t)))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (+.f64 (+.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 b (/.f64 (*.f64 z (log.f64 t)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (+.f64 (+.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 b (/.f64 (*.f64 z (log.f64 t)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (+.f64 (+.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 b (/.f64 (*.f64 z (log.f64 t)) a))))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 (+.f64 x (+.f64 (+.f64 z (*.f64 b #s(literal -1/2 binary64))) (-.f64 y (*.f64 z (log.f64 t))))) a)) (neg.f64 a))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 (+.f64 (neg.f64 a) #s(literal 1/2 binary64)) (/.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) b)))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 (+.f64 (neg.f64 a) #s(literal 1/2 binary64)) (/.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) b)))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 (+.f64 (neg.f64 a) #s(literal 1/2 binary64)) (/.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) b)))
(- (+ y z) (* z (log t)))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
x
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) x))))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) x))))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) x))))
x
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 x (neg.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x)) #s(literal -1 binary64))))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 x (neg.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x)) #s(literal -1 binary64))))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 x (neg.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x)) #s(literal -1 binary64))))
(- (+ x z) (* z (log t)))
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
y
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) (+.f64 (/.f64 x y) #s(literal 1 binary64))))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) (+.f64 (/.f64 x y) #s(literal 1 binary64))))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) (+.f64 (/.f64 x y) #s(literal 1 binary64))))
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 y (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) y)) #s(literal -1 binary64))))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 y (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) y)) #s(literal -1 binary64))))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 y (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) y)) #s(literal -1 binary64))))
(+ x y)
(+.f64 y x)
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(*.f64 z (+.f64 (+.f64 (/.f64 x z) (/.f64 y z)) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(*.f64 z (+.f64 (+.f64 (/.f64 x z) (/.f64 y z)) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(*.f64 z (+.f64 (+.f64 (/.f64 x z) (/.f64 y z)) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (+ 1 (* -1 (log t))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 y x) z)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 y x) z)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 y x) z)) (-.f64 #s(literal 0 binary64) z))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 y (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))) x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 y (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))) x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 y (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))) x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 y (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))) x))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(+ x (* b (- a 1/2)))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)
(+ x (* b (- a 1/2)))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)
(+ x (* b (- a 1/2)))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)
x
(* x (+ 1 (/ (* b (- a 1/2)) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
(* x (+ 1 (/ (* b (- a 1/2)) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
(* x (+ 1 (/ (* b (- a 1/2)) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
x
(* -1 (* x (- (* -1 (/ (* b (- a 1/2)) x)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(* -1 (* x (- (* -1 (/ (* b (- a 1/2)) x)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(* -1 (* x (- (* -1 (/ (* b (- a 1/2)) x)) 1)))
(*.f64 (+.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(+ x (* -1/2 b))
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+ x (+ (* -1/2 b) (* a b)))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)
(+ x (+ (* -1/2 b) (* a b)))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)
(+ x (+ (* -1/2 b) (* a b)))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)
(* a b)
(*.f64 b a)
(* a (+ b (+ (* -1/2 (/ b a)) (/ x a))))
(*.f64 a (+.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (+.f64 b (/.f64 x a))))
(* a (+ b (+ (* -1/2 (/ b a)) (/ x a))))
(*.f64 a (+.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (+.f64 b (/.f64 x a))))
(* a (+ b (+ (* -1/2 (/ b a)) (/ x a))))
(*.f64 a (+.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (+.f64 b (/.f64 x a))))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (* -1/2 b)) a)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 (+.f64 x (*.f64 b #s(literal -1/2 binary64))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (* -1/2 b)) a)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 (+.f64 x (*.f64 b #s(literal -1/2 binary64))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (* -1/2 b)) a)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 (+.f64 x (*.f64 b #s(literal -1/2 binary64))) a)) (neg.f64 a))
x
(+ x (* b (- a 1/2)))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)
(+ x (* b (- a 1/2)))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)
(+ x (* b (- a 1/2)))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- (+ a (/ x b)) 1/2))
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(* b (- (+ a (/ x b)) 1/2))
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(* b (- (+ a (/ x b)) 1/2))
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ x b)))))
(*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 (+.f64 (neg.f64 a) #s(literal 1/2 binary64)) (/.f64 x b)))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ x b)))))
(*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 (+.f64 (neg.f64 a) #s(literal 1/2 binary64)) (/.f64 x b)))
(* -1 (* b (+ (* -1 (- a 1/2)) (* -1 (/ x b)))))
(*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 (+.f64 (neg.f64 a) #s(literal 1/2 binary64)) (/.f64 x b)))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(+ (* -1/2 b) (* a b))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(+ (* -1/2 b) (* a b))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(+ (* -1/2 b) (* a b))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* a b)
(*.f64 b a)
(* a (+ b (* -1/2 (/ b a))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* a (+ b (* -1/2 (/ b a))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* a (+ b (* -1/2 (/ b a))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 b a)) b) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 b a)) b) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 b a)) b) (neg.f64 a))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
-1/2
#s(literal -1/2 binary64)
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
a
(* a (- 1 (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) a)))
(* a (- 1 (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) a)))
(* a (- 1 (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/2 binary64) a)))
a
(* -1 (* a (- (* 1/2 (/ 1 a)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 a (+.f64 (/.f64 #s(literal 1/2 binary64) a) #s(literal -1 binary64))))
(* -1 (* a (- (* 1/2 (/ 1 a)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 a (+.f64 (/.f64 #s(literal 1/2 binary64) a) #s(literal -1 binary64))))
(* -1 (* a (- (* 1/2 (/ 1 a)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 a (+.f64 (/.f64 #s(literal 1/2 binary64) a) #s(literal -1 binary64))))
(+ x y)
(+.f64 y x)
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(*.f64 z (+.f64 (+.f64 (/.f64 x z) (/.f64 y z)) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(*.f64 z (+.f64 (+.f64 (/.f64 x z) (/.f64 y z)) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(*.f64 z (+.f64 (+.f64 (/.f64 x z) (/.f64 y z)) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* -1 (* z (+ (* -1 (- 1 (log t))) (* -1 (/ (+ x y) z)))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 y x) z)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (+ (* -1 (- 1 (log t))) (* -1 (/ (+ x y) z)))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 y x) z)) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (+ (* -1 (- 1 (log t))) (* -1 (/ (+ x y) z)))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 y x) z)) (-.f64 #s(literal 0 binary64) z))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (* -1 (log (/ 1 t)))))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (* -1 (log (/ 1 t)))))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (* -1 (log (/ 1 t)))))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (* -1 (log (/ 1 t)))))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))))
(+.f64 y (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))) x))
(+ x (+ y (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))))
(+.f64 y (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))) x))
(+ x (+ y (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))))
(+.f64 y (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))) x))
(+ x (+ y (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))))
(+.f64 y (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))) x))
(+ x (* z (- 1 (log t))))
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
y
(* y (+ 1 (+ (/ x y) (/ (* z (- 1 (log t))) y))))
(*.f64 y (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) (+.f64 (/.f64 x y) #s(literal 1 binary64))))
(* y (+ 1 (+ (/ x y) (/ (* z (- 1 (log t))) y))))
(*.f64 y (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) (+.f64 (/.f64 x y) #s(literal 1 binary64))))
(* y (+ 1 (+ (/ x y) (/ (* z (- 1 (log t))) y))))
(*.f64 y (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) (+.f64 (/.f64 x y) #s(literal 1 binary64))))
y
(* -1 (* y (- (* -1 (/ (+ x (* z (- 1 (log t)))) y)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 y (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) y)) #s(literal -1 binary64))))
(* -1 (* y (- (* -1 (/ (+ x (* z (- 1 (log t)))) y)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 y (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) y)) #s(literal -1 binary64))))
(* -1 (* y (- (* -1 (/ (+ x (* z (- 1 (log t)))) y)) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 y (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) y)) #s(literal -1 binary64))))
(+ y (* z (- 1 (log t))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
x
(* x (+ 1 (+ (/ y x) (/ (* z (- 1 (log t))) x))))
(*.f64 x (+.f64 (/.f64 y x) (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) #s(literal 1 binary64))))
(* x (+ 1 (+ (/ y x) (/ (* z (- 1 (log t))) x))))
(*.f64 x (+.f64 (/.f64 y x) (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) #s(literal 1 binary64))))
(* x (+ 1 (+ (/ y x) (/ (* z (- 1 (log t))) x))))
(*.f64 x (+.f64 (/.f64 y x) (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) #s(literal 1 binary64))))
x
(* -1 (* x (- (* -1 (/ (+ y (* z (- 1 (log t)))) x)) 1)))
(*.f64 x (neg.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x)) #s(literal -1 binary64))))
(* -1 (* x (- (* -1 (/ (+ y (* z (- 1 (log t)))) x)) 1)))
(*.f64 x (neg.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x)) #s(literal -1 binary64))))
(* -1 (* x (- (* -1 (/ (+ y (* z (- 1 (log t)))) x)) 1)))
(*.f64 x (neg.f64 (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x)) #s(literal -1 binary64))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (* -1 (log (/ 1 t))))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (* -1 (log (/ 1 t))))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (* -1 (log (/ 1 t))))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (* -1 (log (/ 1 t))))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(log t)
(log.f64 t)
(log t)
(log.f64 t)
(log t)
(log.f64 t)
(log t)
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ x b)) (+ (* -1 (/ y b)) (* -1 (/ z b))))) (* -1 (/ (* z (log t)) b)))))
(-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (-.f64 (-.f64 (-.f64 (-.f64 #s(literal 0 binary64) (/.f64 y b)) (/.f64 z b)) (/.f64 x b)) (+.f64 a #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ x b)) (+ (* -1 (/ y b)) (* -1 (/ z b))))) (* -1 (/ (* z (log t)) b)))))
(-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (-.f64 (-.f64 (-.f64 (-.f64 #s(literal 0 binary64) (/.f64 y b)) (/.f64 z b)) (/.f64 x b)) (+.f64 a #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ x b)) (+ (* -1 (/ y b)) (* -1 (/ z b))))) (* -1 (/ (* z (log t)) b)))))
(-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (-.f64 (-.f64 (-.f64 (-.f64 #s(literal 0 binary64) (/.f64 y b)) (/.f64 z b)) (/.f64 x b)) (+.f64 a #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+.f64 x (*.f64 b (+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+.f64 x (*.f64 b (+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+.f64 x (*.f64 b (+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
x
(* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) x)))
(* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) x)))
(* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) x)))
x
(* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))
(*.f64 (+.f64 (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) (-.f64 #s(literal 0 binary64) x)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))
(*.f64 (+.f64 (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) (-.f64 #s(literal 0 binary64) x)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))
(*.f64 (+.f64 (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) (-.f64 #s(literal 0 binary64) x)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) x))
(* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))))
(+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+.f64 y (*.f64 b (+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))))
(+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+.f64 y (*.f64 b (+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))))
(+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+.f64 y (*.f64 b (+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))))
y
(* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b (+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))) y)))
(* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b (+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))) y)))
(* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b (+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))) y)))
y
(* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))
(*.f64 (+.f64 (/.f64 (*.f64 b (+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))) (-.f64 #s(literal 0 binary64) y)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) y))
(* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))
(*.f64 (+.f64 (/.f64 (*.f64 b (+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))) (-.f64 #s(literal 0 binary64) y)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) y))
(* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))
(*.f64 (+.f64 (/.f64 (*.f64 b (+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))) (-.f64 #s(literal 0 binary64) y)) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) y))
(* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* a b)
(*.f64 b a)
(* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))
(*.f64 a (+.f64 b (/.f64 (*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))) a)))
(* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))
(*.f64 a (+.f64 b (/.f64 (*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))) a)))
(* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))
(*.f64 a (+.f64 b (/.f64 (*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))) a)))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 (*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 (*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))
(*.f64 (-.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 (*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))) a)) (neg.f64 a))
(* b (- (+ a (+ (/ x b) (/ y b))) 1/2))
(*.f64 b (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))))
(+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))
(*.f64 b (+.f64 a (+.f64 (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))) (+.f64 (/.f64 x b) (-.f64 (/.f64 y b) #s(literal 1/2 binary64))))))
(+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))
(*.f64 b (+.f64 a (+.f64 (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))) (+.f64 (/.f64 x b) (-.f64 (/.f64 y b) #s(literal 1/2 binary64))))))
(+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))
(*.f64 b (+.f64 a (+.f64 (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))) (+.f64 (/.f64 x b) (-.f64 (/.f64 y b) #s(literal 1/2 binary64))))))
(* b (* z (- (/ 1 b) (/ (log t) b))))
(*.f64 (*.f64 z b) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))
(* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))
(*.f64 z (*.f64 b (+.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) z) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))))
(* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))
(*.f64 z (*.f64 b (+.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) z) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))))
(* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))
(*.f64 z (*.f64 b (+.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) z) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))))
(* b (* z (+ (* -1 (/ (log t) b)) (/ 1 b))))
(*.f64 (*.f64 z b) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))
(* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))
(*.f64 (neg.f64 (*.f64 b (+.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) z) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))
(*.f64 (neg.f64 (*.f64 b (+.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) z) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))) (-.f64 #s(literal 0 binary64) z))
(* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))
(*.f64 (neg.f64 (*.f64 b (+.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) z) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))) (-.f64 #s(literal 0 binary64) z))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(*.f64 b (+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(*.f64 b (-.f64 (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))) (/.f64 (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) b)))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(*.f64 b (-.f64 (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))) (/.f64 (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) b)))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(*.f64 b (-.f64 (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))) (/.f64 (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) b)))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(*.f64 b (-.f64 (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))) (/.f64 (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) b)))
(- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(/ x b)
(/.f64 x b)
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (+.f64 (+.f64 (/.f64 y (*.f64 b x)) (/.f64 (/.f64 z b) x)) (/.f64 (+.f64 a #s(literal -1/2 binary64)) x)) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b x)))))
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (+.f64 (+.f64 (/.f64 y (*.f64 b x)) (/.f64 (/.f64 z b) x)) (/.f64 (+.f64 a #s(literal -1/2 binary64)) x)) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b x)))))
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (+.f64 (+.f64 (/.f64 y (*.f64 b x)) (/.f64 (/.f64 z b) x)) (/.f64 (+.f64 a #s(literal -1/2 binary64)) x)) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b x)))))
(/ x b)
(/.f64 x b)
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 x (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))) (-.f64 #s(literal 0 binary64) x)) (/.f64 #s(literal -1 binary64) b))))
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 x (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))) (-.f64 #s(literal 0 binary64) x)) (/.f64 #s(literal -1 binary64) b))))
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 x (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 z b) (+.f64 (/.f64 y b) a)) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))) (-.f64 #s(literal 0 binary64) x)) (/.f64 #s(literal -1 binary64) b))))
(/ (- (+ x (+ y z)) (* z (log t))) b)
(/.f64 (+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) b)
(/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)
(/.f64 (+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) b)
(/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)
(/.f64 (+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) b)
(/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)
(/.f64 (+.f64 y (+.f64 x (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))) b)
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
(- (+ a (* -1 (/ (- (+ (* -1 x) (+ (* -1 y) (* -1 z))) (* -1 (* z (log t)))) b))) 1/2)
(+.f64 (-.f64 a (/.f64 (+.f64 (-.f64 (-.f64 #s(literal 0 binary64) x) y) (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64)))) b)) #s(literal -1/2 binary64))
(- (+ a (* -1 (/ (- (+ (* -1 x) (+ (* -1 y) (* -1 z))) (* -1 (* z (log t)))) b))) 1/2)
(+.f64 (-.f64 a (/.f64 (+.f64 (-.f64 (-.f64 #s(literal 0 binary64) x) y) (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64)))) b)) #s(literal -1/2 binary64))
(- (+ a (* -1 (/ (- (+ (* -1 x) (+ (* -1 y) (* -1 z))) (* -1 (* z (log t)))) b))) 1/2)
(+.f64 (-.f64 a (/.f64 (+.f64 (-.f64 (-.f64 #s(literal 0 binary64) x) y) (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64)))) b)) #s(literal -1/2 binary64))
(- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(/ y b)
(/.f64 y b)
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (+.f64 (+.f64 (/.f64 (/.f64 x b) y) (/.f64 z (*.f64 y b))) (/.f64 (+.f64 a #s(literal -1/2 binary64)) y)) (/.f64 (*.f64 z (log.f64 t)) (*.f64 y b)))))
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (+.f64 (+.f64 (/.f64 (/.f64 x b) y) (/.f64 z (*.f64 y b))) (/.f64 (+.f64 a #s(literal -1/2 binary64)) y)) (/.f64 (*.f64 z (log.f64 t)) (*.f64 y b)))))
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (+.f64 (+.f64 (/.f64 (/.f64 x b) y) (/.f64 z (*.f64 y b))) (/.f64 (+.f64 a #s(literal -1/2 binary64)) y)) (/.f64 (*.f64 z (log.f64 t)) (*.f64 y b)))))
(/ y b)
(/.f64 y b)
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))
(*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (/.f64 (+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) (-.f64 #s(literal 0 binary64) y)) (/.f64 #s(literal -1 binary64) b)))
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))
(*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (/.f64 (+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) (-.f64 #s(literal 0 binary64) y)) (/.f64 #s(literal -1 binary64) b)))
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))
(*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (/.f64 (+.f64 a (+.f64 (/.f64 x b) (-.f64 (/.f64 z b) (+.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) (-.f64 #s(literal 0 binary64) y)) (/.f64 #s(literal -1 binary64) b)))
(- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))
(-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
a
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))
(*.f64 a (+.f64 (+.f64 (+.f64 (/.f64 y (*.f64 b a)) (/.f64 z (*.f64 b a))) (+.f64 (/.f64 x (*.f64 b a)) #s(literal 1 binary64))) (-.f64 (/.f64 #s(literal -1/2 binary64) a) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b a)))))
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))
(*.f64 a (+.f64 (+.f64 (+.f64 (/.f64 y (*.f64 b a)) (/.f64 z (*.f64 b a))) (+.f64 (/.f64 x (*.f64 b a)) #s(literal 1 binary64))) (-.f64 (/.f64 #s(literal -1/2 binary64) a) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b a)))))
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))
(*.f64 a (+.f64 (+.f64 (+.f64 (/.f64 y (*.f64 b a)) (/.f64 z (*.f64 b a))) (+.f64 (/.f64 x (*.f64 b a)) #s(literal 1 binary64))) (-.f64 (/.f64 #s(literal -1/2 binary64) a) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b a)))))
a
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))
(*.f64 (+.f64 (/.f64 (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))
(*.f64 (+.f64 (/.f64 (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))
(*.f64 (+.f64 (/.f64 (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(- (+ a (+ (/ x b) (/ y b))) 1/2)
(+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64)))
(- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)
(+.f64 a (+.f64 (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))) (+.f64 (/.f64 x b) (-.f64 (/.f64 y b) #s(literal 1/2 binary64)))))
(- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)
(+.f64 a (+.f64 (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))) (+.f64 (/.f64 x b) (-.f64 (/.f64 y b) #s(literal 1/2 binary64)))))
(- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)
(+.f64 a (+.f64 (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))) (+.f64 (/.f64 x b) (-.f64 (/.f64 y b) #s(literal 1/2 binary64)))))
(* z (- (/ 1 b) (/ (log t) b)))
(*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (+.f64 (+.f64 (/.f64 x (*.f64 z b)) (/.f64 y (*.f64 z b))) (/.f64 (+.f64 a #s(literal -1/2 binary64)) z)) (/.f64 (log.f64 t) b))))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (+.f64 (+.f64 (/.f64 x (*.f64 z b)) (/.f64 y (*.f64 z b))) (/.f64 (+.f64 a #s(literal -1/2 binary64)) z)) (/.f64 (log.f64 t) b))))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (+.f64 (+.f64 (/.f64 x (*.f64 z b)) (/.f64 y (*.f64 z b))) (/.f64 (+.f64 a #s(literal -1/2 binary64)) z)) (/.f64 (log.f64 t) b))))
(* z (+ (* -1 (/ (log t) b)) (/ 1 b)))
(*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))
(*.f64 (-.f64 #s(literal 0 binary64) z) (-.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (-.f64 #s(literal 0 binary64) z)) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))
(*.f64 (-.f64 #s(literal 0 binary64) z) (-.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (-.f64 #s(literal 0 binary64) z)) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))
(*.f64 (-.f64 #s(literal 0 binary64) z) (-.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (-.f64 #s(literal 0 binary64) z)) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(+.f64 a (-.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(-.f64 (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))) (/.f64 (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) b))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(-.f64 (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))) (/.f64 (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) b))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(-.f64 (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))) (/.f64 (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) b))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(-.f64 (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))) (/.f64 (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) b))
(- (+ a (+ (/ y b) (/ z b))) 1/2)
(+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(/ x b)
(/.f64 x b)
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (* 1/2 (/ 1 x))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (/.f64 y (*.f64 b x)) (/.f64 (/.f64 z b) x)) (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (* 1/2 (/ 1 x))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (/.f64 y (*.f64 b x)) (/.f64 (/.f64 z b) x)) (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (* 1/2 (/ 1 x))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (/.f64 y (*.f64 b x)) (/.f64 (/.f64 z b) x)) (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
(/ x b)
(/.f64 x b)
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) 1/2) x)) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 x (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a #s(literal -1/2 binary64))) (-.f64 #s(literal 0 binary64) x)) (/.f64 #s(literal -1 binary64) b))))
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) 1/2) x)) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 x (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a #s(literal -1/2 binary64))) (-.f64 #s(literal 0 binary64) x)) (/.f64 #s(literal -1 binary64) b))))
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) 1/2) x)) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 x (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a #s(literal -1/2 binary64))) (-.f64 #s(literal 0 binary64) x)) (/.f64 #s(literal -1 binary64) b))))
(/ (+ x (+ y z)) b)
(/.f64 (+.f64 z (+.f64 y x)) b)
(/ (+ x (+ y (+ z (* b (- a 1/2))))) b)
(/.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) b)
(/ (+ x (+ y (+ z (* b (- a 1/2))))) b)
(/.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) b)
(/ (+ x (+ y (+ z (* b (- a 1/2))))) b)
(/.f64 (+.f64 y (+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (+.f64 z x))) b)
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
(- (+ a (* -1 (/ (+ (* -1 x) (+ (* -1 y) (* -1 z))) b))) 1/2)
(+.f64 (-.f64 a (/.f64 (-.f64 (-.f64 (-.f64 #s(literal 0 binary64) x) y) z) b)) #s(literal -1/2 binary64))
(- (+ a (* -1 (/ (+ (* -1 x) (+ (* -1 y) (* -1 z))) b))) 1/2)
(+.f64 (-.f64 a (/.f64 (-.f64 (-.f64 (-.f64 #s(literal 0 binary64) x) y) z) b)) #s(literal -1/2 binary64))
(- (+ a (* -1 (/ (+ (* -1 x) (+ (* -1 y) (* -1 z))) b))) 1/2)
(+.f64 (-.f64 a (/.f64 (-.f64 (-.f64 (-.f64 #s(literal 0 binary64) x) y) z) b)) #s(literal -1/2 binary64))
(- (+ a (+ (/ x b) (/ z b))) 1/2)
(+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 z b) #s(literal -1/2 binary64)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(/ y b)
(/.f64 y b)
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (* 1/2 (/ 1 y))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (/.f64 (/.f64 x b) y) (/.f64 z (*.f64 y b))) (/.f64 (+.f64 a #s(literal -1/2 binary64)) y))))
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (* 1/2 (/ 1 y))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (/.f64 (/.f64 x b) y) (/.f64 z (*.f64 y b))) (/.f64 (+.f64 a #s(literal -1/2 binary64)) y))))
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (* 1/2 (/ 1 y))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (/.f64 (/.f64 x b) y) (/.f64 z (*.f64 y b))) (/.f64 (+.f64 a #s(literal -1/2 binary64)) y))))
(/ y b)
(/.f64 y b)
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) 1/2) y)) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 y (+.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 z b) #s(literal -1/2 binary64))) (-.f64 #s(literal 0 binary64) y)) (/.f64 #s(literal -1 binary64) b))))
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) 1/2) y)) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 y (+.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 z b) #s(literal -1/2 binary64))) (-.f64 #s(literal 0 binary64) y)) (/.f64 #s(literal -1 binary64) b))))
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) 1/2) y)) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 y (+.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 z b) #s(literal -1/2 binary64))) (-.f64 #s(literal 0 binary64) y)) (/.f64 #s(literal -1 binary64) b))))
(- (+ (/ x b) (+ (/ y b) (/ z b))) 1/2)
(+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
a
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 y (*.f64 b a)) (/.f64 z (*.f64 b a))) (-.f64 (/.f64 x (*.f64 b a)) (/.f64 #s(literal 1/2 binary64) a)))))
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 y (*.f64 b a)) (/.f64 z (*.f64 b a))) (-.f64 (/.f64 x (*.f64 b a)) (/.f64 #s(literal 1/2 binary64) a)))))
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (+.f64 (+.f64 (/.f64 y (*.f64 b a)) (/.f64 z (*.f64 b a))) (-.f64 (/.f64 x (*.f64 b a)) (/.f64 #s(literal 1/2 binary64) a)))))
a
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) 1/2) a)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) 1/2) a)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) 1/2) a)) 1)))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))) (neg.f64 a)) #s(literal -1 binary64)) (neg.f64 a))
(- (+ a (+ (/ x b) (/ y b))) 1/2)
(+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) 1/2)
(+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(/ z b)
(/.f64 z b)
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (* 1/2 (/ 1 z))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (/.f64 x (*.f64 z b)) (/.f64 y (*.f64 z b))) (/.f64 (+.f64 a #s(literal -1/2 binary64)) z))))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (* 1/2 (/ 1 z))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (/.f64 x (*.f64 z b)) (/.f64 y (*.f64 z b))) (/.f64 (+.f64 a #s(literal -1/2 binary64)) z))))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (* 1/2 (/ 1 z))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (/.f64 x (*.f64 z b)) (/.f64 y (*.f64 z b))) (/.f64 (+.f64 a #s(literal -1/2 binary64)) z))))
(/ z b)
(/.f64 z b)
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 z (+.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (-.f64 #s(literal 0 binary64) z)) (/.f64 #s(literal -1 binary64) b))))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 z (+.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (-.f64 #s(literal 0 binary64) z)) (/.f64 #s(literal -1 binary64) b))))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 z (+.f64 (/.f64 (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (-.f64 #s(literal 0 binary64) z)) (/.f64 #s(literal -1 binary64) b))))
(/ y b)
(/.f64 y b)
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(/ x b)
(/.f64 x b)
(* x (+ (/ 1 b) (/ y (* b x))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 y (*.f64 b x))))
(* x (+ (/ 1 b) (/ y (* b x))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 y (*.f64 b x))))
(* x (+ (/ 1 b) (/ y (* b x))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 y (*.f64 b x))))
(/ x b)
(/.f64 x b)
(* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 x (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 y (*.f64 b x))) (/.f64 #s(literal -1 binary64) b))))
(* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 x (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 y (*.f64 b x))) (/.f64 #s(literal -1 binary64) b))))
(* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))
(-.f64 #s(literal 0 binary64) (*.f64 x (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 y (*.f64 b x))) (/.f64 #s(literal -1 binary64) b))))
(/ (+ x y) b)
(/.f64 (+.f64 y x) b)
(/ (+ x y) b)
(/.f64 (+.f64 y x) b)
(/ (+ x y) b)
(/.f64 (+.f64 y x) b)
(/ (+ x y) b)
(/.f64 (+.f64 y x) b)
(/ (+ x y) b)
(/.f64 (+.f64 y x) b)
(/ (+ x y) b)
(/.f64 (+.f64 y x) b)
(/ (+ x y) b)
(/.f64 (+.f64 y x) b)
(/ (+ x y) b)
(/.f64 (+.f64 y x) b)
(* -1 (/ (+ (* -1 x) (* -1 y)) b))
(-.f64 #s(literal 0 binary64) (/.f64 (-.f64 (-.f64 #s(literal 0 binary64) x) y) b))
(* -1 (/ (+ (* -1 x) (* -1 y)) b))
(-.f64 #s(literal 0 binary64) (/.f64 (-.f64 (-.f64 #s(literal 0 binary64) x) y) b))
(* -1 (/ (+ (* -1 x) (* -1 y)) b))
(-.f64 #s(literal 0 binary64) (/.f64 (-.f64 (-.f64 #s(literal 0 binary64) x) y) b))
(* -1 (/ (+ (* -1 x) (* -1 y)) b))
(-.f64 #s(literal 0 binary64) (/.f64 (-.f64 (-.f64 #s(literal 0 binary64) x) y) b))
(/ x b)
(/.f64 x b)
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(/ y b)
(/.f64 y b)
(* y (+ (/ 1 b) (/ x (* b y))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (/.f64 x b) y)))
(* y (+ (/ 1 b) (/ x (* b y))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (/.f64 x b) y)))
(* y (+ (/ 1 b) (/ x (* b y))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (/.f64 x b) y)))
(/ y b)
(/.f64 y b)
(* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))
(*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (/.f64 x b) y)) (/.f64 #s(literal -1 binary64) b)))
(* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))
(*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (/.f64 x b) y)) (/.f64 #s(literal -1 binary64) b)))
(* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))
(*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 (/.f64 x b) y)) (/.f64 #s(literal -1 binary64) b)))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* -1 (* z (log (/ 1 t))))
(*.f64 z (log.f64 t))
(* -1 (* z (log (/ 1 t))))
(*.f64 z (log.f64 t))
(* -1 (* z (log (/ 1 t))))
(*.f64 z (log.f64 t))
(* -1 (* z (log (/ 1 t))))
(*.f64 z (log.f64 t))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(- z (* z (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(- (+ y z) (* z (log t)))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ y z) (* z (log t)))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ y z) (* z (log t)))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
y
(* y (- (+ 1 (/ z y)) (/ (* z (log t)) y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) y))))
(* y (- (+ 1 (/ z y)) (/ (* z (log t)) y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) y))))
(* y (- (+ 1 (/ z y)) (/ (* z (log t)) y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) y))))
y
(* -1 (* y (- (* -1 (/ (- z (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (/.f64 (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64))) y) #s(literal -1 binary64)))
(* -1 (* y (- (* -1 (/ (- z (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (/.f64 (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64))) y) #s(literal -1 binary64)))
(* -1 (* y (- (* -1 (/ (- z (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal 0 binary64) y) (+.f64 (/.f64 (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64))) y) #s(literal -1 binary64)))
y
(+ y (* z (- 1 (log t))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(+ y (* z (- 1 (log t))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(+ y (* z (- 1 (log t))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- (+ 1 (/ y z)) (log t)))
(*.f64 z (+.f64 (/.f64 y z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- (+ 1 (/ y z)) (log t)))
(*.f64 z (+.f64 (/.f64 y z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- (+ 1 (/ y z)) (log t)))
(*.f64 z (+.f64 (/.f64 y z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (+ 1 (* -1 (log t))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* -1 (* z (- (* -1 (/ y z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 #s(literal 0 binary64) z) (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 y z)) (+.f64 (log.f64 t) #s(literal -1 binary64))))
(* -1 (* z (- (* -1 (/ y z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 #s(literal 0 binary64) z) (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 y z)) (+.f64 (log.f64 t) #s(literal -1 binary64))))
(* -1 (* z (- (* -1 (/ y z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 #s(literal 0 binary64) z) (+.f64 (-.f64 #s(literal 0 binary64) (/.f64 y z)) (+.f64 (log.f64 t) #s(literal -1 binary64))))
(- (+ y z) (* z (log t)))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ y z) (* z (log t)))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ y z) (* z (log t)))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ y z) (* z (log t)))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ y z) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ y z) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ y z) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ y z) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ y z) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(- (+ y z) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(- (+ y z) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(- (+ y z) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))

eval222.0ms (1.7%)

Memory
12.5MiB live, 403.5MiB allocated
Compiler

Compiled 43 848 to 3 364 computations (92.3% saved)

prune252.0ms (2%)

Memory
-18.1MiB live, 392.1MiB allocated
Pruning

34 alts after pruning (32 fresh and 2 done)

PrunedKeptTotal
New1 399241 423
Fresh5813
Picked325
Done000
Total1 407341 441
Accuracy
100.0%
Counts
1 441 → 34
Alt Table
Click to see full alt table
StatusAccuracyProgram
16.7%
(/.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 x x)) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))
▶21.5%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
37.2%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
24.4%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b a)))
24.3%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
▶20.1%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
▶77.2%
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
57.2%
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
✓62.9%
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
60.2%
(+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
44.0%
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
42.6%
(+.f64 y x)
32.7%
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64))))))
▶46.7%
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64))))
47.7%
(+.f64 x (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))) b))
40.1%
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
42.2%
(+.f64 x (*.f64 b a))
33.5%
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
48.0%
(+.f64 x (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a))))
16.6%
(*.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
73.3%
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t))))) b)
19.0%
(*.f64 (*.f64 z b) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))
21.5%
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
50.1%
(*.f64 x (+.f64 (/.f64 y x) (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) #s(literal 1 binary64))))
46.5%
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
15.1%
(*.f64 b (/.f64 y b))
13.8%
(*.f64 b (/.f64 x b))
49.1%
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
37.3%
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
12.3%
(*.f64 b (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
24.4%
(*.f64 b a)
71.4%
(*.f64 a (+.f64 (+.f64 b (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (*.f64 z (/.f64 (log.f64 t) a)))))
▶24.4%
y
✓20.2%
x
Compiler

Compiled 1 093 to 776 computations (29% saved)

simplify372.0ms (2.9%)

Memory
23.1MiB live, 407.6MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 14 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(-.f64 #s(literal 1 binary64) (log.f64 t))
✓cost-diff0
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
✓cost-diff0
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
✓cost-diff256
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
✓cost-diff0
(+.f64 (*.f64 a a) #s(literal -1/4 binary64))
✓cost-diff0
(*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b)
✓cost-diff0
(/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64)))
✓cost-diff0
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64))))
✓cost-diff0
(/.f64 #s(literal 1 binary64) x)
✓cost-diff256
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
✓cost-diff0
(+.f64 x y)
✓cost-diff0
(+.f64 (+.f64 x y) z)
✓cost-diff0
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
✓cost-diff0
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
Rules
5 728×accelerator-lowering-fma.f32
5 728×accelerator-lowering-fma.f64
1 416×*-lowering-*.f32
1 416×*-lowering-*.f64
1 280×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
029130
161130
2149130
3356130
4788130
51669130
63009130
74206130
84912130
95254130
106067130
116134130
126139130
136653130
146889130
156889130
166893130
176893130
187075130
197075130
07075122
Stop Event
1×iter limit
1×saturated
Calls
Call 1
Inputs
(+ (- (+ (+ x y) z) (* z (log t))) (* b -1/2))
(- (+ (+ x y) z) (* z (log t)))
(+ (+ x y) z)
(+ x y)
x
y
z
(* z (log t))
(log t)
t
(* b -1/2)
b
-1/2
y
(/ 1 (/ 1 x))
1
(/ 1 x)
x
(+ x (/ (* (+ (* a a) -1/4) b) (+ a 1/2)))
x
(/ (* (+ (* a a) -1/4) b) (+ a 1/2))
(* (+ (* a a) -1/4) b)
(+ (* a a) -1/4)
(* a a)
a
-1/4
b
(+ a 1/2)
1/2
(/ 1 (/ 1 (* z (- 1 (log t)))))
1
(/ 1 (* z (- 1 (log t))))
(* z (- 1 (log t)))
z
(- 1 (log t))
(log t)
t
Outputs
(+ (- (+ (+ x y) z) (* z (log t))) (* b -1/2))
(+.f64 y (+.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ (+ x y) z) (* z (log t)))
(+.f64 y (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ (+ x y) z)
(+.f64 x (+.f64 y z))
(+ x y)
(+.f64 x y)
x
y
z
(* z (log t))
(*.f64 z (log.f64 t))
(log t)
(log.f64 t)
t
(* b -1/2)
(*.f64 b #s(literal -1/2 binary64))
b
-1/2
#s(literal -1/2 binary64)
y
(/ 1 (/ 1 x))
x
1
#s(literal 1 binary64)
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
x
(+ x (/ (* (+ (* a a) -1/4) b) (+ a 1/2)))
(+.f64 x (/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 a #s(literal 1/2 binary64))))
x
(/ (* (+ (* a a) -1/4) b) (+ a 1/2))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 a #s(literal 1/2 binary64)))
(* (+ (* a a) -1/4) b)
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(+ (* a a) -1/4)
(+.f64 (*.f64 a a) #s(literal -1/4 binary64))
(* a a)
(*.f64 a a)
a
-1/4
#s(literal -1/4 binary64)
b
(+ a 1/2)
(+.f64 a #s(literal 1/2 binary64))
1/2
#s(literal 1/2 binary64)
(/ 1 (/ 1 (* z (- 1 (log t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
1
#s(literal 1 binary64)
(/ 1 (* z (- 1 (log t))))
(/.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) z)
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
z
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(log t)
(log.f64 t)
t

localize100.0ms (0.8%)

Memory
-21.7MiB live, 213.8MiB allocated
Localize:

Found 14 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(-.f64 #s(literal 1 binary64) (log.f64 t))
✓accuracy99.6%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
✓accuracy99.6%
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
✓accuracy99.5%
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
✓accuracy100.0%
(+.f64 a #s(literal 1/2 binary64))
✓accuracy100.0%
(*.f64 a a)
✓accuracy95.5%
(*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b)
✓accuracy88.5%
(/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64)))
✓accuracy100.0%
(/.f64 #s(literal 1 binary64) x)
✓accuracy99.7%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
✓accuracy100.0%
(*.f64 b #s(literal -1/2 binary64))
✓accuracy100.0%
(log.f64 t)
✓accuracy99.9%
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
✓accuracy99.6%
(*.f64 z (log.f64 t))
Samples
57.0ms256×0valid
Compiler

Compiled 140 to 31 computations (77.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 33.0ms
ival-mult: 11.0ms (33.2% of total)
ival-div: 8.0ms (24.2% of total)
ival-add: 7.0ms (21.1% of total)
ival-log: 3.0ms (9.1% of total)
ival-sub: 2.0ms (6% of total)
ival-true: 0.0ms (0% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series21.0ms (0.2%)

Memory
25.7MiB live, 61.3MiB allocated
Counts
19 → 444
Calls
Call 1
Inputs
#<alt (+ (- (+ (+ x y) z) (* z (log t))) (* b -1/2))>
#<alt (- (+ (+ x y) z) (* z (log t)))>
#<alt (+ (+ x y) z)>
#<alt (+ x y)>
#<alt (/ 1 (/ 1 x))>
#<alt (/ 1 x)>
#<alt (+ x (/ (* (+ (* a a) -1/4) b) (+ a 1/2)))>
#<alt (/ (* (+ (* a a) -1/4) b) (+ a 1/2))>
#<alt (* (+ (* a a) -1/4) b)>
#<alt (+ (* a a) -1/4)>
#<alt (/ 1 (/ 1 (* z (- 1 (log t)))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (* z (- 1 (log t)))>
#<alt (- 1 (log t))>
#<alt (* z (log t))>
#<alt (log t)>
#<alt (* b -1/2)>
#<alt (* a a)>
#<alt (+ a 1/2)>
Outputs
#<alt (- (+ y (+ z (* -1/2 b))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt x>
#<alt (* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (/ z x)))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (/ z x)))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (/ z x)))) (/ (* z (log t)) x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (* -1/2 b))) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (* -1/2 b))) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (* -1/2 b))) (* z (log t))) x)) 1)))>
#<alt (- (+ x (+ z (* -1/2 b))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt y>
#<alt (* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (/ z y)))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (/ z y)))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (/ z y)))) (/ (* z (log t)) y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (* -1/2 b))) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (* -1/2 b))) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (* -1/2 b))) (* z (log t))) y)) 1)))>
#<alt (+ x (+ y (* -1/2 b)))>
#<alt (+ x (+ y (+ (* -1/2 b) (* z (- 1 (log t))))))>
#<alt (+ x (+ y (+ (* -1/2 b) (* z (- 1 (log t))))))>
#<alt (+ x (+ y (+ (* -1/2 b) (* z (- 1 (log t))))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (/ y z)))) (log t)))>
#<alt (* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (/ y z)))) (log t)))>
#<alt (* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (/ y z)))) (log t)))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (* -1/2 b))) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (* -1/2 b))) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (* -1/2 b))) z)) (+ 1 (* -1 (log t))))))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))>
#<alt (* -1/2 b)>
#<alt (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* -1/2 b)>
#<alt (* -1 (* b (+ 1/2 (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))>
#<alt (* -1 (* b (+ 1/2 (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))>
#<alt (* -1 (* b (+ 1/2 (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))>
#<alt (- (+ y z) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt x>
#<alt (* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))>
#<alt (- (+ x z) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt y>
#<alt (* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))>
#<alt (+ x y)>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (+ x (+ y (* z (- 1 (log t)))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))>
#<alt (* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (+ y z)>
#<alt (+ x (+ y z))>
#<alt (+ x (+ y z))>
#<alt (+ x (+ y z))>
#<alt x>
#<alt (* x (+ 1 (+ (/ y x) (/ z x))))>
#<alt (* x (+ 1 (+ (/ y x) (/ z x))))>
#<alt (* x (+ 1 (+ (/ y x) (/ z x))))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))>
#<alt (+ x z)>
#<alt (+ x (+ y z))>
#<alt (+ x (+ y z))>
#<alt (+ x (+ y z))>
#<alt y>
#<alt (* y (+ 1 (+ (/ x y) (/ z y))))>
#<alt (* y (+ 1 (+ (/ x y) (/ z y))))>
#<alt (* y (+ 1 (+ (/ x y) (/ z y))))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))>
#<alt (+ x y)>
#<alt (+ x (+ y z))>
#<alt (+ x (+ y z))>
#<alt (+ x (+ y z))>
#<alt z>
#<alt (* z (+ 1 (+ (/ x z) (/ y z))))>
#<alt (* z (+ 1 (+ (/ x z) (/ y z))))>
#<alt (* z (+ 1 (+ (/ x z) (/ y z))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))>
#<alt y>
#<alt (+ x y)>
#<alt (+ x y)>
#<alt (+ x y)>
#<alt x>
#<alt (* x (+ 1 (/ y x)))>
#<alt (* x (+ 1 (/ y x)))>
#<alt (* x (+ 1 (/ y x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ y x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ y x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ y x)) 1)))>
#<alt x>
#<alt (+ x y)>
#<alt (+ x y)>
#<alt (+ x y)>
#<alt y>
#<alt (* y (+ 1 (/ x y)))>
#<alt (* y (+ 1 (/ x y)))>
#<alt (* y (+ 1 (/ x y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ x y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ x y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ x y)) 1)))>
#<alt x>
#<alt x>
#<alt x>
#<alt x>
#<alt x>
#<alt x>
#<alt x>
#<alt x>
#<alt x>
#<alt x>
#<alt x>
#<alt x>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (+ x (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a)))>
#<alt (+ x (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a)))>
#<alt (+ x (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a)))>
#<alt x>
#<alt (* x (+ 1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))))>
#<alt (* x (+ 1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))))>
#<alt (* x (+ 1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))) 1)))>
#<alt (+ x (* -1/2 b))>
#<alt (+ x (+ (* -1/2 b) (* a b)))>
#<alt (+ x (+ (* -1/2 b) (* a b)))>
#<alt (+ x (+ (* -1/2 b) (* a b)))>
#<alt (* a b)>
#<alt (* a (- (+ b (/ x a)) (* 1/2 (/ b a))))>
#<alt (* a (- (+ b (/ x a)) (* 1/2 (/ b a))))>
#<alt (* a (- (+ b (/ x a)) (* 1/2 (/ b a))))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))>
#<alt x>
#<alt (+ x (* b (- (/ (pow a 2) (+ 1/2 a)) (* 1/4 (/ 1 (+ 1/2 a))))))>
#<alt (+ x (* b (- (/ (pow a 2) (+ 1/2 a)) (* 1/4 (/ 1 (+ 1/2 a))))))>
#<alt (+ x (* b (- (/ (pow a 2) (+ 1/2 a)) (* 1/4 (/ 1 (+ 1/2 a))))))>
#<alt (* b (- (/ (pow a 2) (+ 1/2 a)) (* 1/4 (/ 1 (+ 1/2 a)))))>
#<alt (* b (- (+ (/ x b) (/ (pow a 2) (+ 1/2 a))) (* 1/4 (/ 1 (+ 1/2 a)))))>
#<alt (* b (- (+ (/ x b) (/ (pow a 2) (+ 1/2 a))) (* 1/4 (/ 1 (+ 1/2 a)))))>
#<alt (* b (- (+ (/ x b) (/ (pow a 2) (+ 1/2 a))) (* 1/4 (/ 1 (+ 1/2 a)))))>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (* -1 (* b (+ (* -1 (/ x b)) (* -1 (/ (- (pow a 2) 1/4) (+ 1/2 a))))))>
#<alt (* -1 (* b (+ (* -1 (/ x b)) (* -1 (/ (- (pow a 2) 1/4) (+ 1/2 a))))))>
#<alt (* -1 (* b (+ (* -1 (/ x b)) (* -1 (/ (- (pow a 2) 1/4) (+ 1/2 a))))))>
#<alt (* -1/2 b)>
#<alt (+ (* -1/2 b) (* a b))>
#<alt (+ (* -1/2 b) (* a b))>
#<alt (+ (* -1/2 b) (* a b))>
#<alt (* a b)>
#<alt (* a (+ b (* -1/2 (/ b a))))>
#<alt (* a (+ b (* -1/2 (/ b a))))>
#<alt (* a (+ b (* -1/2 (/ b a))))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))>
#<alt (* -1/4 b)>
#<alt (+ (* -1/4 b) (* (pow a 2) b))>
#<alt (+ (* -1/4 b) (* (pow a 2) b))>
#<alt (+ (* -1/4 b) (* (pow a 2) b))>
#<alt (* (pow a 2) b)>
#<alt (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))>
#<alt (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))>
#<alt (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))>
#<alt (* (pow a 2) b)>
#<alt (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))>
#<alt (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))>
#<alt (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))>
#<alt (* b (- (pow a 2) 1/4))>
#<alt (* b (- (pow a 2) 1/4))>
#<alt (* b (- (pow a 2) 1/4))>
#<alt (* b (- (pow a 2) 1/4))>
#<alt (* b (- (pow a 2) 1/4))>
#<alt (* b (- (pow a 2) 1/4))>
#<alt (* b (- (pow a 2) 1/4))>
#<alt (* b (- (pow a 2) 1/4))>
#<alt (* b (- (pow a 2) 1/4))>
#<alt (* b (- (pow a 2) 1/4))>
#<alt (* b (- (pow a 2) 1/4))>
#<alt (* b (- (pow a 2) 1/4))>
#<alt -1/4>
#<alt (- (pow a 2) 1/4)>
#<alt (- (pow a 2) 1/4)>
#<alt (- (pow a 2) 1/4)>
#<alt (pow a 2)>
#<alt (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (pow a 2)>
#<alt (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (log t))))>
#<alt (/ 1 (* z (- 1 (* -1 (log (/ 1 t))))))>
#<alt (/ 1 (* z (- 1 (* -1 (log (/ 1 t))))))>
#<alt (/ 1 (* z (- 1 (* -1 (log (/ 1 t))))))>
#<alt (/ 1 (* z (- 1 (* -1 (log (/ 1 t))))))>
#<alt (/ 1 (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))))>
#<alt (/ 1 (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))))>
#<alt (/ 1 (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))))>
#<alt (/ 1 (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- 1 (log t))>
#<alt (- 1 (log t))>
#<alt (- 1 (log t))>
#<alt (- 1 (log t))>
#<alt (- 1 (* -1 (log (/ 1 t))))>
#<alt (- 1 (* -1 (log (/ 1 t))))>
#<alt (- 1 (* -1 (log (/ 1 t))))>
#<alt (- 1 (* -1 (log (/ 1 t))))>
#<alt (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* z (log t))>
#<alt (* -1 (* z (log (/ 1 t))))>
#<alt (* -1 (* z (log (/ 1 t))))>
#<alt (* -1 (* z (log (/ 1 t))))>
#<alt (* -1 (* z (log (/ 1 t))))>
#<alt (* z (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (* z (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (* z (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (* z (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (log t)>
#<alt (log t)>
#<alt (log t)>
#<alt (log t)>
#<alt (* -1 (log (/ 1 t)))>
#<alt (* -1 (log (/ 1 t)))>
#<alt (* -1 (log (/ 1 t)))>
#<alt (* -1 (log (/ 1 t)))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt 1/2>
#<alt (+ 1/2 a)>
#<alt (+ 1/2 a)>
#<alt (+ 1/2 a)>
#<alt a>
#<alt (* a (+ 1 (* 1/2 (/ 1 a))))>
#<alt (* a (+ 1 (* 1/2 (/ 1 a))))>
#<alt (* a (+ 1 (* 1/2 (/ 1 a))))>
#<alt a>
#<alt (* a (+ 1 (* 1/2 (/ 1 a))))>
#<alt (* a (+ 1 (* 1/2 (/ 1 a))))>
#<alt (* a (+ 1 (* 1/2 (/ 1 a))))>
Calls

111 calls:

TimeVariablePointExpression
3.0ms
t
@0
(/ 1 (* z (- 1 (log t))))
1.0ms
b
@inf
(+ x (/ (* (+ (* a a) -1/4) b) (+ a 1/2)))
1.0ms
x
@0
(+ x (/ (* (+ (* a a) -1/4) b) (+ a 1/2)))
1.0ms
a
@inf
(+ x (/ (* (+ (* a a) -1/4) b) (+ a 1/2)))
1.0ms
b
@0
(+ x (/ (* (+ (* a a) -1/4) b) (+ a 1/2)))

rewrite764.0ms (6%)

Memory
3.2MiB live, 847.4MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
5 190×*-lowering-*.f32
5 190×*-lowering-*.f64
4 306×/-lowering-/.f32
4 306×/-lowering-/.f64
2 688×accelerator-lowering-fma.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
029111
119499
2181499
0864295
Stop Event
1×iter limit
1×node limit
Counts
19 → 712
Calls
Call 1
Inputs
(+ (- (+ (+ x y) z) (* z (log t))) (* b -1/2))
(- (+ (+ x y) z) (* z (log t)))
(+ (+ x y) z)
(+ x y)
(/ 1 (/ 1 x))
(/ 1 x)
(+ x (/ (* (+ (* a a) -1/4) b) (+ a 1/2)))
(/ (* (+ (* a a) -1/4) b) (+ a 1/2))
(* (+ (* a a) -1/4) b)
(+ (* a a) -1/4)
(/ 1 (/ 1 (* z (- 1 (log t)))))
(/ 1 (* z (- 1 (log t))))
(* z (- 1 (log t)))
(- 1 (log t))
(* z (log t))
(log t)
(* b -1/2)
(* a a)
(+ a 1/2)
Outputs
(+.f64 x (-.f64 (+.f64 y z) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(+.f64 (+.f64 x y) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64))))
(+.f64 (+.f64 x y) (-.f64 z (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(+.f64 z (-.f64 (+.f64 x y) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(+.f64 (+.f64 x (+.f64 y z)) (neg.f64 (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(+.f64 (+.f64 x (+.f64 y z)) (+.f64 (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64))))
(+.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))
(+.f64 (+.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 x y)) (-.f64 z (*.f64 z (log.f64 t))))
(+.f64 (+.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 x (+.f64 y z))) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))
(-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b)))
(-.f64 (/.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64))))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64))))))
(-.f64 (+.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 x (+.f64 y z))) (*.f64 z (log.f64 t)))
(fma.f64 x #s(literal 1 binary64) (-.f64 (+.f64 y z) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(fma.f64 b #s(literal -1/2 binary64) (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))
(fma.f64 #s(literal -1/2 binary64) b (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))
(fma.f64 #s(literal 1 binary64) x (-.f64 (+.f64 y z) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) x) (-.f64 (+.f64 y z) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(fma.f64 #s(literal -1 binary64) (pow.f64 (-.f64 #s(literal 0 binary64) x) #s(literal 1 binary64)) (-.f64 (+.f64 y z) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64))))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (-.f64 z (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(fma.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (neg.f64 (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(fma.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (+.f64 (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64))))
(fma.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (*.f64 b #s(literal -1/2 binary64)))
(fma.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64))))
(fma.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (-.f64 z (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(fma.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))) (neg.f64 (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(fma.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))) (+.f64 (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64))))
(fma.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 b #s(literal -1/2 binary64)))
(fma.f64 (pow.f64 x #s(literal 1/2 binary64)) (pow.f64 x #s(literal 1/2 binary64)) (-.f64 (+.f64 y z) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(fma.f64 (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (-.f64 (+.f64 y z) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(fma.f64 (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (-.f64 (+.f64 y z) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 b #s(literal -1/2 binary64)) (-.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))) (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 b #s(literal -1/2 binary64)) (-.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))) (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))))))
(/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 b #s(literal -1/2 binary64)) (-.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))))
(/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (-.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 b #s(literal -1/2 binary64)) (-.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))) (neg.f64 (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (-.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (*.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b)))) (neg.f64 (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 (pow.f64 (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))))
(/.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64))) (-.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b)) #s(literal 2 binary64))) (+.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))) (*.f64 (/.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (/.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))))) (*.f64 (/.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))) (*.f64 (/.f64 (+.f64 x (-.f64 y z)) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (/.f64 (+.f64 x (-.f64 y z)) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (/.f64 (+.f64 x (-.f64 y z)) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))))) (*.f64 (/.f64 (+.f64 x (-.f64 y z)) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))))) (*.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))))) (*.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))) (*.f64 (+.f64 x (-.f64 y z)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 x (-.f64 y z)) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (*.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (+.f64 x (-.f64 y z)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))))) (*.f64 (+.f64 x (-.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (neg.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))) (*.f64 (neg.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (*.f64 (neg.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (neg.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))))) (*.f64 (neg.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))) (*.f64 (neg.f64 (+.f64 x (-.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (neg.f64 (+.f64 x (-.f64 y z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (*.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (neg.f64 (+.f64 x (-.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))))) (*.f64 (neg.f64 (+.f64 x (-.f64 y z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))) (*.f64 (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z)))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z)))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z)))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))))) (*.f64 (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z)))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) (+.f64 y z))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))) (*.f64 (-.f64 x (+.f64 y z)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 x (+.f64 y z)) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) (+.f64 y z))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (-.f64 x (+.f64 y z)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))))) (*.f64 (-.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))) (*.f64 (-.f64 z (+.f64 x y)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (*.f64 (-.f64 z (+.f64 x y)) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (*.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 (-.f64 z (+.f64 x y)) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))))) (*.f64 (-.f64 z (+.f64 x y)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (*.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64))))) (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (*.f64 #s(literal 1/4 binary64) (*.f64 b b)))) (*.f64 (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (neg.f64 (neg.f64 (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 b #s(literal -1/2 binary64)) (-.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))))) (neg.f64 (neg.f64 (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 (pow.f64 (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b)) #s(literal 2 binary64)))) (neg.f64 (+.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 #s(literal 1/2 binary64) b)))))
(pow.f64 (/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 b #s(literal -1/2 binary64)) (-.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))) (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64)))) (-.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b)))) #s(literal -1 binary64))
(*.f64 (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 3 binary64)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 (*.f64 b #s(literal -1/2 binary64)) (-.f64 (*.f64 b #s(literal -1/2 binary64)) (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))))))
(*.f64 (-.f64 (pow.f64 (+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) #s(literal 2 binary64)) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 y z)) (+.f64 (*.f64 z (log.f64 t)) (*.f64 b #s(literal -1/2 binary64))))))
(+.f64 x (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))))
(+.f64 x (+.f64 (+.f64 y z) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t)))))
(+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(+.f64 y (+.f64 x (-.f64 z (*.f64 z (log.f64 t)))))
(+.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))
(+.f64 z (+.f64 (+.f64 x y) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t)))))
(+.f64 z (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))))
(+.f64 (+.f64 x (+.f64 y z)) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))
(+.f64 (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))) (+.f64 x (+.f64 y z)))
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) (+.f64 x y))
(-.f64 (+.f64 x (+.f64 y z)) (*.f64 z (log.f64 t)))
(-.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))
(-.f64 (/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(fma.f64 x #s(literal 1 binary64) (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))))
(fma.f64 x #s(literal 1 binary64) (+.f64 (+.f64 y z) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t)))))
(fma.f64 x #s(literal 1 binary64) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(fma.f64 z (-.f64 #s(literal 0 binary64) (log.f64 t)) (+.f64 x (+.f64 y z)))
(fma.f64 (log.f64 t) (-.f64 #s(literal 0 binary64) z) (+.f64 x (+.f64 y z)))
(fma.f64 #s(literal 1 binary64) x (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))))
(fma.f64 #s(literal 1 binary64) x (+.f64 (+.f64 y z) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t)))))
(fma.f64 #s(literal 1 binary64) x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(fma.f64 #s(literal -1 binary64) (*.f64 z (log.f64 t)) (+.f64 x (+.f64 y z)))
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) x) (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))))
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) x) (+.f64 (+.f64 y z) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t)))))
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) x) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(fma.f64 #s(literal -1 binary64) (pow.f64 (-.f64 #s(literal 0 binary64) x) #s(literal 1 binary64)) (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))))
(fma.f64 #s(literal -1 binary64) (pow.f64 (-.f64 #s(literal 0 binary64) x) #s(literal 1 binary64)) (+.f64 (+.f64 y z) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t)))))
(fma.f64 #s(literal -1 binary64) (pow.f64 (-.f64 #s(literal 0 binary64) x) #s(literal 1 binary64)) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))
(fma.f64 (-.f64 #s(literal 0 binary64) (log.f64 t)) z (+.f64 x (+.f64 y z)))
(fma.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))
(fma.f64 (-.f64 #s(literal 0 binary64) z) (log.f64 t) (+.f64 x (+.f64 y z)))
(fma.f64 (pow.f64 x #s(literal 1/2 binary64)) (pow.f64 x #s(literal 1/2 binary64)) (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))))
(fma.f64 (pow.f64 x #s(literal 1/2 binary64)) (pow.f64 x #s(literal 1/2 binary64)) (+.f64 (+.f64 y z) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t)))))
(fma.f64 (pow.f64 x #s(literal 1/2 binary64)) (pow.f64 x #s(literal 1/2 binary64)) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(fma.f64 (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))))
(fma.f64 (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (+.f64 (+.f64 y z) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t)))))
(fma.f64 (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(fma.f64 (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))))
(fma.f64 (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (+.f64 (+.f64 y z) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t)))))
(fma.f64 (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (-.f64 (+.f64 y z) (*.f64 z (log.f64 t))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t)))))))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))
(/.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (-.f64 (+.f64 x (+.f64 y z)) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (-.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 y z)) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (neg.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 x (+.f64 y z)) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))))
(/.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))) (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (/.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (/.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (/.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (/.f64 (-.f64 x y) (-.f64 (*.f64 x x) (*.f64 y y))) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (/.f64 (-.f64 x y) (-.f64 (*.f64 x x) (*.f64 y y))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (/.f64 (-.f64 x y) (-.f64 (*.f64 x x) (*.f64 y y))) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (/.f64 (-.f64 x y) (-.f64 (*.f64 x x) (*.f64 y y))) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y))) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y))) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y))) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (-.f64 x y) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (-.f64 x y) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (-.f64 x y) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (-.f64 x y) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (neg.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (neg.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 x x) (*.f64 y y))) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (neg.f64 (-.f64 x y)) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (neg.f64 (-.f64 x y)) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 (*.f64 x x) (*.f64 y y))) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (neg.f64 (-.f64 x y)) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (neg.f64 (-.f64 x y)) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))) (*.f64 (-.f64 y x) (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (*.f64 (-.f64 y x) (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (+.f64 z (*.f64 z (log.f64 t)))) (*.f64 (-.f64 y x) (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (*.f64 (-.f64 y x) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (/.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 (-.f64 x y) (-.f64 (*.f64 x x) (*.f64 y y)))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (/.f64 (-.f64 x y) (-.f64 (*.f64 x x) (*.f64 y y)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (-.f64 x y)) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (-.f64 (*.f64 x x) (*.f64 y y)))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (-.f64 x y)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (neg.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (neg.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (neg.f64 (-.f64 x y))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (neg.f64 (-.f64 (*.f64 x x) (*.f64 y y))))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (neg.f64 (-.f64 x y))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z (*.f64 z z)) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (-.f64 y x)) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (-.f64 (*.f64 y y) (*.f64 x x)))) (*.f64 (+.f64 (*.f64 z z) (+.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z (*.f64 z (log.f64 t))))) (-.f64 y x)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) #s(literal 1 binary64))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (/.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 (-.f64 x y) (-.f64 (*.f64 x x) (*.f64 y y)))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) #s(literal 1 binary64))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (/.f64 (-.f64 x y) (-.f64 (*.f64 x x) (*.f64 y y)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (-.f64 x y)) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (-.f64 (*.f64 x x) (*.f64 y y)))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (-.f64 x y)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (neg.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (neg.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (neg.f64 (-.f64 x y))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (neg.f64 (-.f64 (*.f64 x x) (*.f64 y y))))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (neg.f64 (-.f64 x y))))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (-.f64 y x)) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (-.f64 (*.f64 y y) (*.f64 x x)))) (*.f64 (+.f64 z (*.f64 z (log.f64 t))) (-.f64 y x)))
(/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))) (*.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) (pow.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) #s(literal 2 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))) (*.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) (pow.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) #s(literal 2 binary64)))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t))))))
(pow.f64 (/.f64 (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (*.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))))
(*.f64 (-.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 (+.f64 y z) (*.f64 z (log.f64 t))))))
(+.f64 x (+.f64 y z))
(+.f64 y (+.f64 x z))
(+.f64 (+.f64 x y) z)
(+.f64 z (+.f64 x y))
(+.f64 (+.f64 y z) x)
(+.f64 (+.f64 z x) y)
(-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (/.f64 (*.f64 z z) (+.f64 x (-.f64 y z))))
(fma.f64 x #s(literal 1 binary64) (+.f64 y z))
(fma.f64 #s(literal 1 binary64) x (+.f64 y z))
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) x) (+.f64 y z))
(fma.f64 #s(literal -1 binary64) (pow.f64 (-.f64 #s(literal 0 binary64) x) #s(literal 1 binary64)) (+.f64 y z))
(fma.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) z)
(fma.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) z)
(fma.f64 (pow.f64 x #s(literal 1/2 binary64)) (pow.f64 x #s(literal 1/2 binary64)) (+.f64 y z))
(fma.f64 (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (+.f64 y z))
(fma.f64 (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (+.f64 y z))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 x (-.f64 y z)) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 x (-.f64 y z)) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)))))
(/.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))))
(/.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))))
(/.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (+.f64 x (-.f64 y z)))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (neg.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) (neg.f64 (+.f64 (*.f64 z z) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) (neg.f64 (+.f64 x (-.f64 y z))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z)))))
(/.f64 (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) (+.f64 y z))) (-.f64 x (+.f64 y z)))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (-.f64 z (+.f64 x y)))
(/.f64 (+.f64 (*.f64 x (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z)))) (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 y (*.f64 y y)) (*.f64 z (*.f64 z z))))) (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z)))))
(/.f64 (+.f64 (*.f64 x (-.f64 y z)) (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 y y) (*.f64 z z)))) (*.f64 #s(literal 1 binary64) (-.f64 y z)))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z)))) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 (*.f64 y (*.f64 y y)) (*.f64 z (*.f64 z z))))) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 y z)) (*.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 (*.f64 y y) (*.f64 z z)))) (*.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 y z)))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z)))) (*.f64 (/.f64 #s(literal -1 binary64) x) (+.f64 (*.f64 y (*.f64 y y)) (*.f64 z (*.f64 z z))))) (*.f64 (/.f64 #s(literal -1 binary64) x) (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z)))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (-.f64 y z)) (*.f64 (/.f64 #s(literal -1 binary64) x) (-.f64 (*.f64 y y) (*.f64 z z)))) (*.f64 (/.f64 #s(literal -1 binary64) x) (-.f64 y z)))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z)))) (*.f64 #s(literal -1 binary64) (+.f64 (*.f64 y (*.f64 y y)) (*.f64 z (*.f64 z z))))) (*.f64 #s(literal -1 binary64) (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z)))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (-.f64 y z)) (*.f64 #s(literal -1 binary64) (-.f64 (*.f64 y y) (*.f64 z z)))) (*.f64 #s(literal -1 binary64) (-.f64 y z)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 y (*.f64 y y)) (*.f64 z (*.f64 z z))) #s(literal 1 binary64)) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z))) x)) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z))) #s(literal 1 binary64)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 y (*.f64 y y)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z))) (/.f64 #s(literal 1 binary64) x)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 y (*.f64 y y)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal -1 binary64) x)) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z))) #s(literal -1 binary64))) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z))) (/.f64 #s(literal -1 binary64) x)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 y (*.f64 y y)) (*.f64 z (*.f64 z z))) #s(literal -1 binary64)) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z))) (-.f64 #s(literal 0 binary64) x))) (*.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 z z) (*.f64 y z))) #s(literal -1 binary64)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 y y) (*.f64 z z)) #s(literal 1 binary64)) (*.f64 (-.f64 y z) x)) (*.f64 (-.f64 y z) #s(literal 1 binary64)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 y y) (*.f64 z z)) (/.f64 #s(literal 1 binary64) x)) (*.f64 (-.f64 y z) #s(literal 1 binary64))) (*.f64 (-.f64 y z) (/.f64 #s(literal 1 binary64) x)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 y y) (*.f64 z z)) (/.f64 #s(literal -1 binary64) x)) (*.f64 (-.f64 y z) #s(literal -1 binary64))) (*.f64 (-.f64 y z) (/.f64 #s(literal -1 binary64) x)))
(/.f64 (+.f64 (*.f64 (-.f64 (*.f64 y y) (*.f64 z z)) #s(literal -1 binary64)) (*.f64 (-.f64 y z) (-.f64 #s(literal 0 binary64) x))) (*.f64 (-.f64 y z) #s(literal -1 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (*.f64 (+.f64 x (-.f64 y z)) (*.f64 z z))) (*.f64 (+.f64 x (-.f64 y z)) (+.f64 x (-.f64 y z))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))))) (neg.f64 (neg.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)))) (neg.f64 (neg.f64 (+.f64 x (-.f64 y z)))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))))) (neg.f64 (+.f64 (*.f64 x x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z))))))
(/.f64 (neg.f64 (-.f64 (*.f64 x x) (*.f64 (+.f64 y z) (+.f64 y z)))) (neg.f64 (-.f64 x (+.f64 y z))))
(/.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 z (+.f64 x y))))
(pow.f64 (/.f64 (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y)))) (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 x (-.f64 y z)) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (-.f64 z (+.f64 x y))))))
(*.f64 (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))))
(+.f64 x y)
(+.f64 y x)
(-.f64 (/.f64 (*.f64 x x) (-.f64 x y)) (/.f64 (*.f64 y y) (-.f64 x y)))
(fma.f64 x #s(literal 1 binary64) y)
(fma.f64 #s(literal 1 binary64) x y)
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) x) y)
(fma.f64 #s(literal -1 binary64) (pow.f64 (-.f64 #s(literal 0 binary64) x) #s(literal 1 binary64)) y)
(fma.f64 (pow.f64 x #s(literal 1/2 binary64)) (pow.f64 x #s(literal 1/2 binary64)) y)
(fma.f64 (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) y)
(fma.f64 (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) y)
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 x y) (-.f64 (*.f64 x x) (*.f64 y y))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 x y) (-.f64 (*.f64 x x) (*.f64 y y)))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y))))
(/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (-.f64 x y))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (neg.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (neg.f64 (+.f64 (*.f64 y y) (-.f64 (*.f64 x x) (*.f64 x y)))))
(/.f64 (neg.f64 (-.f64 (*.f64 x x) (*.f64 y y))) (neg.f64 (-.f64 x y)))
(/.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (-.f64 y x))
(/.f64 (-.f64 (*.f64 (*.f64 x x) (-.f64 x y)) (*.f64 (-.f64 x y) (*.f64 y y))) (*.f64 (-.f64 x y) (-.f64 x y)))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (neg.f64 (neg.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 x x) (*.f64 y y)))) (neg.f64 (neg.f64 (-.f64 x y))))
(/.f64 (neg.f64 (-.f64 (*.f64 y y) (*.f64 x x))) (neg.f64 (-.f64 y x)))
(pow.f64 (/.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 x y) (-.f64 (*.f64 x x) (*.f64 y y))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))))
(*.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)))
x
(exp.f64 (log.f64 x))
(exp.f64 (*.f64 (log.f64 x) #s(literal 1 binary64)))
(neg.f64 (-.f64 #s(literal 0 binary64) x))
(/.f64 x #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) x))
(/.f64 (-.f64 #s(literal 0 binary64) x) #s(literal -1 binary64))
(pow.f64 x #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) x) #s(literal -1 binary64))
(pow.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 #s(literal 1 binary64) x)) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 2 binary64))
(*.f64 x #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) x)
(*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) x))
(*.f64 #s(literal -1 binary64) (pow.f64 (-.f64 #s(literal 0 binary64) x) #s(literal 1 binary64)))
(*.f64 (pow.f64 x #s(literal 1/2 binary64)) (pow.f64 x #s(literal 1/2 binary64)))
(*.f64 (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(exp.f64 (-.f64 #s(literal 0 binary64) (log.f64 x)))
(exp.f64 (*.f64 (-.f64 #s(literal 0 binary64) (log.f64 x)) #s(literal 1 binary64)))
(neg.f64 (/.f64 #s(literal -1 binary64) x))
(/.f64 #s(literal 1 binary64) x)
(/.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) x))
(/.f64 (/.f64 #s(literal -1 binary64) x) #s(literal -1 binary64))
(pow.f64 x #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 1 binary64))
(pow.f64 (*.f64 x x) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal 2 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
(*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) x))
(*.f64 #s(literal -1 binary64) (pow.f64 (/.f64 #s(literal -1 binary64) x) #s(literal 1 binary64)))
(*.f64 (pow.f64 x #s(literal -1/2 binary64)) (pow.f64 x #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)
(-.f64 (/.f64 (*.f64 x x) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 x #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x)
(fma.f64 b (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))) x)
(fma.f64 #s(literal 1 binary64) x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(fma.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)
(fma.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) x)
(fma.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) x) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(fma.f64 #s(literal -1 binary64) (pow.f64 (-.f64 #s(literal 0 binary64) x) #s(literal 1 binary64)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(fma.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) x)
(fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) x)
(fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) #s(literal -1 binary64)) x)
(fma.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64))) x)
(fma.f64 (/.f64 b (+.f64 a #s(literal 1/2 binary64))) (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) x)
(fma.f64 (pow.f64 x #s(literal 1/2 binary64)) (pow.f64 x #s(literal 1/2 binary64)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(fma.f64 (/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) x)
(fma.f64 (/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 a #s(literal -1/2 binary64)) x)
(fma.f64 (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 x #s(literal 1/2 binary64)) #s(literal 1 binary64)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(fma.f64 (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 x #s(literal -1/2 binary64)) #s(literal -1 binary64)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) x))))
(/.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))))) (*.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (*.f64 (/.f64 #s(literal -1 binary64) x) #s(literal 1 binary64))) (*.f64 (/.f64 #s(literal -1 binary64) x) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (*.f64 (/.f64 #s(literal -1 binary64) x) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 (/.f64 #s(literal -1 binary64) x) (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))))) (*.f64 (/.f64 #s(literal -1 binary64) x) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)))
(/.f64 (+.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal -1 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal -1 binary64) x)))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 a #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) x)))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 #s(literal -1 binary64) x)) (*.f64 (+.f64 a #s(literal 1/2 binary64)) #s(literal -1 binary64))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) x)))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) #s(literal 1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) x)))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) (/.f64 #s(literal -1 binary64) x)) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) #s(literal -1 binary64))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) (/.f64 #s(literal -1 binary64) x)))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (+.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)))))
(/.f64 (neg.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (neg.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 x x)) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))
(/.f64 (+.f64 (*.f64 x (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1 binary64)) (*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 x (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64))) #s(literal 1 binary64)) (*.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64))))
(/.f64 (+.f64 (*.f64 x (+.f64 a #s(literal 1/2 binary64))) (*.f64 #s(literal 1 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (*.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 x (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64)) (*.f64 #s(literal 1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 x (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))))) (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 x (+.f64 a #s(literal 1/2 binary64))) (*.f64 #s(literal 1 binary64) (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal 1 binary64)))) (*.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 x (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 #s(literal 1 binary64) (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b))) (*.f64 #s(literal 1 binary64) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 x (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 #s(literal 1 binary64) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) b))) (*.f64 #s(literal 1 binary64) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 x (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))) (*.f64 #s(literal 1 binary64) (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))))) (*.f64 #s(literal 1 binary64) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 x (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))) (*.f64 #s(literal 1 binary64) (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))))) (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))))
(/.f64 (+.f64 (*.f64 x (+.f64 (*.f64 a a) #s(literal 1/4 binary64))) (*.f64 #s(literal 1 binary64) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))))) (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) #s(literal 1/4 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (*.f64 (/.f64 #s(literal 1 binary64) x) #s(literal -1 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) x) (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal 1 binary64)))) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b))) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) b))) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))) (*.f64 (/.f64 #s(literal 1 binary64) x) (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))))) (*.f64 (/.f64 #s(literal 1 binary64) x) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))))) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))))
(/.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) #s(literal 1/4 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))))) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 (*.f64 a a) #s(literal 1/4 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (/.f64 #s(literal -1 binary64) x) #s(literal 1 binary64))) (*.f64 (/.f64 #s(literal -1 binary64) x) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (*.f64 (/.f64 #s(literal -1 binary64) x) #s(literal -1 binary64))) (*.f64 (/.f64 #s(literal -1 binary64) x) (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal 1 binary64)))) (*.f64 (/.f64 #s(literal -1 binary64) x) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b))) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) b))) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))) (*.f64 (/.f64 #s(literal -1 binary64) x) (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))))) (*.f64 (/.f64 #s(literal -1 binary64) x) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))))) (*.f64 (/.f64 #s(literal -1 binary64) x) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))))
(/.f64 (+.f64 (*.f64 #s(literal -1 binary64) (+.f64 (*.f64 a a) #s(literal 1/4 binary64))) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))))) (*.f64 (/.f64 #s(literal -1 binary64) x) (+.f64 (*.f64 a a) #s(literal 1/4 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1 binary64)) (*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64))) #s(literal -1 binary64)) (*.f64 #s(literal -1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (+.f64 a #s(literal 1/2 binary64))) (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal 1 binary64)) (*.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))))) (*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (+.f64 a #s(literal 1/2 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal 1 binary64)))) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b))) (*.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) b))) (*.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))) (*.f64 #s(literal -1 binary64) (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))))) (*.f64 #s(literal -1 binary64) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))) (*.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))))) (*.f64 #s(literal -1 binary64) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) x) (+.f64 (*.f64 a a) #s(literal 1/4 binary64))) (*.f64 #s(literal -1 binary64) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))))) (*.f64 #s(literal -1 binary64) (+.f64 (*.f64 a a) #s(literal 1/4 binary64))))
(/.f64 (+.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) x)) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)))
(/.f64 (+.f64 #s(literal -1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 #s(literal 0 binary64) x))) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal -1 binary64)))
(/.f64 (+.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)) x)) (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)) #s(literal 1 binary64)))
(/.f64 (+.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)) #s(literal 1 binary64))) (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) x)))
(/.f64 (+.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)) #s(literal -1 binary64))) (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)) (/.f64 #s(literal -1 binary64) x)))
(/.f64 (+.f64 #s(literal -1 binary64) (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) x))) (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)) #s(literal -1 binary64)))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal 1 binary64)) (*.f64 (+.f64 a #s(literal 1/2 binary64)) x)) (*.f64 (+.f64 a #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(/.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal -1 binary64)) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) x))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) #s(literal -1 binary64)))
(/.f64 (+.f64 #s(literal -1 binary64) (*.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) x)) (*.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1 binary64)))
(/.f64 (+.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal 1 binary64))) (*.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) x)))
(/.f64 (+.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1 binary64))) (*.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) x)))
(/.f64 (+.f64 #s(literal 1 binary64) (*.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 #s(literal 0 binary64) x))) (*.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1 binary64)))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) #s(literal 1 binary64)) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) x)) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(/.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) #s(literal -1 binary64)) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) (-.f64 #s(literal 0 binary64) x))) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) #s(literal -1 binary64)))
(/.f64 (+.f64 (*.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal 1 binary64)) #s(literal 1 binary64)) (*.f64 (+.f64 a #s(literal 1/2 binary64)) x)) (*.f64 (+.f64 a #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(/.f64 (+.f64 (*.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 a #s(literal 1/2 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) x)))
(/.f64 (+.f64 (*.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal -1 binary64) x)) (*.f64 (+.f64 a #s(literal 1/2 binary64)) #s(literal -1 binary64))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) x)))
(/.f64 (+.f64 (*.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal 1 binary64)) #s(literal -1 binary64)) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (-.f64 #s(literal 0 binary64) x))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) #s(literal -1 binary64)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) #s(literal 1 binary64)) (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64))) x)) (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) (/.f64 #s(literal 1 binary64) x)) (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64))) #s(literal 1 binary64))) (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) x)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) (/.f64 #s(literal -1 binary64) x)) (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64))) #s(literal -1 binary64))) (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 #s(literal -1 binary64) x)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) #s(literal -1 binary64)) (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64))) (-.f64 #s(literal 0 binary64) x))) (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64))) #s(literal -1 binary64)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) b) #s(literal 1 binary64)) (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))) x)) (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) b) (/.f64 #s(literal 1 binary64) x)) (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))) #s(literal 1 binary64))) (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) x)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) b) (/.f64 #s(literal -1 binary64) x)) (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))) #s(literal -1 binary64))) (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))) (/.f64 #s(literal -1 binary64) x)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) b) #s(literal -1 binary64)) (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))) (-.f64 #s(literal 0 binary64) x))) (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))) #s(literal -1 binary64)))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) #s(literal 1 binary64)) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) x)) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) #s(literal 1 binary64)))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) #s(literal 1 binary64))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (/.f64 #s(literal -1 binary64) x)) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) #s(literal -1 binary64))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal -1 binary64) x)))
(/.f64 (+.f64 (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) #s(literal -1 binary64)) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) (-.f64 #s(literal 0 binary64) x))) (*.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) #s(literal -1 binary64)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) #s(literal 1 binary64)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) x)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) #s(literal 1 binary64)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (/.f64 #s(literal 1 binary64) x)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal -1 binary64) x)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) #s(literal -1 binary64))) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (/.f64 #s(literal -1 binary64) x)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) #s(literal -1 binary64)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (-.f64 #s(literal 0 binary64) x))) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) #s(literal -1 binary64)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) #s(literal 1 binary64)) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) x)) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) #s(literal 1 binary64)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (/.f64 #s(literal 1 binary64) x)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal -1 binary64) x)) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) #s(literal -1 binary64))) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (/.f64 #s(literal -1 binary64) x)))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) #s(literal -1 binary64)) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (-.f64 #s(literal 0 binary64) x))) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) #s(literal -1 binary64)))
(/.f64 (-.f64 (*.f64 (*.f64 x x) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (*.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (*.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (+.f64 (*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) x))) (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))))) (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (+.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))))) (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))))
(/.f64 (neg.f64 (+.f64 (*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (*.f64 (/.f64 #s(literal -1 binary64) x) #s(literal 1 binary64)))) (neg.f64 (*.f64 (/.f64 #s(literal -1 binary64) x) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (+.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) (*.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))))) (neg.f64 (*.f64 (/.f64 #s(literal -1 binary64) x) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (+.f64 (*.f64 #s(literal -1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))) (*.f64 (/.f64 #s(literal -1 binary64) x) (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))))) (neg.f64 (*.f64 (/.f64 #s(literal -1 binary64) x) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))))
(/.f64 (neg.f64 (+.f64 (/.f64 #s(literal 1 binary64) x) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)))) (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) x))))
(/.f64 (neg.f64 (+.f64 (/.f64 #s(literal -1 binary64) x) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal -1 binary64)))) (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal -1 binary64) x))))
(/.f64 (neg.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 a #s(literal 1/2 binary64)) #s(literal 1 binary64)))) (neg.f64 (*.f64 (+.f64 a #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) x))))
(/.f64 (neg.f64 (+.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 #s(literal -1 binary64) x)) (*.f64 (+.f64 a #s(literal 1/2 binary64)) #s(literal -1 binary64)))) (neg.f64 (*.f64 (+.f64 a #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) x))))
(/.f64 (neg.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) #s(literal 1 binary64)))) (neg.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) x))))
(/.f64 (neg.f64 (+.f64 (*.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) (/.f64 #s(literal -1 binary64) x)) (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) #s(literal -1 binary64)))) (neg.f64 (*.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))) (/.f64 #s(literal -1 binary64) x))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (neg.f64 (neg.f64 (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (neg.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 x x))) (neg.f64 (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)))
(pow.f64 (/.f64 (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x)))))
(*.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1 binary64)))
(neg.f64 (/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal 1 binary64)) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) b) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))) (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))))
(/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 a a) #s(literal 1/4 binary64)))
(/.f64 (neg.f64 (*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal 1 binary64))) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b)) (neg.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) b)) (neg.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))))) (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64))))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64))))) (neg.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64))))) (neg.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64))))
(pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 b (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))))
(*.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(*.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (+.f64 a #s(literal 1/2 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) #s(literal -1 binary64)))
(*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64))))
(*.f64 (/.f64 b (+.f64 a #s(literal 1/2 binary64))) (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(*.f64 (/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))
(*.f64 (/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 a #s(literal -1/2 binary64)))
(+.f64 (*.f64 b (*.f64 a a)) (*.f64 b #s(literal -1/4 binary64)))
(+.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 b (*.f64 a a)))
(+.f64 (*.f64 (*.f64 a a) b) (*.f64 #s(literal -1/4 binary64) b))
(+.f64 (*.f64 #s(literal -1/4 binary64) b) (*.f64 (*.f64 a a) b))
(fma.f64 b (*.f64 a a) (*.f64 b #s(literal -1/4 binary64)))
(fma.f64 b #s(literal -1/4 binary64) (*.f64 b (*.f64 a a)))
(fma.f64 (*.f64 a a) b (*.f64 #s(literal -1/4 binary64) b))
(fma.f64 #s(literal -1/4 binary64) b (*.f64 (*.f64 a a) b))
(/.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))))
(/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) b) (+.f64 (*.f64 a a) #s(literal 1/4 binary64)))
(/.f64 (*.f64 b (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64))) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))))
(/.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64))) (+.f64 (*.f64 a a) #s(literal 1/4 binary64)))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b)) (neg.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) b)) (neg.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64))))
(/.f64 (neg.f64 (*.f64 b (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)))) (neg.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))))
(/.f64 (neg.f64 (*.f64 b (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)))) (neg.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64))))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b)
(+.f64 (*.f64 a a) #s(literal -1/4 binary64))
(+.f64 #s(literal -1/4 binary64) (*.f64 a a))
(-.f64 (*.f64 a a) #s(literal 1/4 binary64))
(-.f64 (/.f64 (*.f64 a (*.f64 a (*.f64 a a))) (+.f64 (*.f64 a a) #s(literal 1/4 binary64))) (/.f64 #s(literal 1/16 binary64) (+.f64 (*.f64 a a) #s(literal 1/4 binary64))))
(fma.f64 a a #s(literal -1/4 binary64))
(fma.f64 (exp.f64 (log.f64 a)) (exp.f64 (log.f64 a)) #s(literal -1/4 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)))))
(/.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))))
(/.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (+.f64 #s(literal 1/16 binary64) (-.f64 (*.f64 a (*.f64 a (*.f64 a a))) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))))
(/.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) (+.f64 (*.f64 a a) #s(literal 1/4 binary64)))
(/.f64 (neg.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64))) (neg.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64))) (neg.f64 (+.f64 #s(literal 1/16 binary64) (-.f64 (*.f64 a (*.f64 a (*.f64 a a))) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64))) (neg.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64))))
(/.f64 (-.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal 1/64 binary64)) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (+.f64 #s(literal 1/16 binary64) (*.f64 (*.f64 a a) #s(literal 1/4 binary64)))))
(/.f64 (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a (*.f64 a a)))) (-.f64 #s(literal -1/4 binary64) (*.f64 a a)))
(/.f64 (-.f64 (*.f64 (*.f64 a (*.f64 a (*.f64 a a))) (+.f64 (*.f64 a a) #s(literal 1/4 binary64))) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) #s(literal 1/16 binary64))) (*.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 (*.f64 a a) #s(literal 1/4 binary64))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal 1/64 binary64))) (neg.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (+.f64 #s(literal 1/16 binary64) (*.f64 (*.f64 a a) #s(literal 1/4 binary64))))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)))) (neg.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)))) (neg.f64 (neg.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a (*.f64 a a))))) (neg.f64 (-.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(pow.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (*.f64 a a) #s(literal 1/4 binary64)) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))))
(*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) #s(literal -1/16 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) #s(literal 1/4 binary64))))
(+.f64 (*.f64 z #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))
(+.f64 (*.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))
(exp.f64 (log.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(exp.f64 (*.f64 (log.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal 1 binary64)))
(fma.f64 z #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))
(fma.f64 #s(literal 1 binary64) z (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))
(neg.f64 (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 0 binary64) z)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64))
(/.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64)))))
(/.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (+.f64 (log.f64 t) #s(literal 1 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) z) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64)))))
(/.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) z) (+.f64 (log.f64 t) #s(literal 1 binary64)))
(/.f64 (neg.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64))))))
(/.f64 (neg.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (neg.f64 (+.f64 (log.f64 t) #s(literal 1 binary64))))
(/.f64 (neg.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) z)) (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64))))))
(/.f64 (neg.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) z)) (neg.f64 (+.f64 (log.f64 t) #s(literal 1 binary64))))
(pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t))) (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal -1/2 binary64))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 z #s(literal 1 binary64)))
(*.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 0 binary64) z)))
(*.f64 #s(literal -1 binary64) (pow.f64 (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 0 binary64) z)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1/2 binary64)) (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) z)
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (pow.f64 (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)))
(*.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)) (pow.f64 (/.f64 z #s(literal 1 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 #s(literal 1 binary64) z) #s(literal 1 binary64)) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) #s(literal 1 binary64)) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)))
(*.f64 (pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64))))))
(*.f64 (pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (log.f64 t) #s(literal 1 binary64))))
(exp.f64 (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal 1 binary64)))
(neg.f64 (/.f64 #s(literal -1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 #s(literal 1 binary64) z)))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 0 binary64) z)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 #s(literal 1 binary64) z))))
(/.f64 (/.f64 #s(literal -1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t)))
(/.f64 (/.f64 #s(literal 1 binary64) z) (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/.f64 (neg.f64 (/.f64 #s(literal 1 binary64) z)) (neg.f64 (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/.f64 (neg.f64 (/.f64 #s(literal 1 binary64) z)) (neg.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) z)
(/.f64 (neg.f64 (neg.f64 (/.f64 #s(literal 1 binary64) z))) (neg.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t)))) (-.f64 #s(literal 0 binary64) z))
(pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1 binary64))
(pow.f64 (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 #s(literal 1 binary64) z)) #s(literal -1 binary64))
(pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal -1/2 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(*.f64 #s(literal -1 binary64) (pow.f64 (/.f64 #s(literal -1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(*.f64 (/.f64 #s(literal 1 binary64) z) (pow.f64 (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) (/.f64 #s(literal 1 binary64) z))
(*.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1/2 binary64)) (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1/2 binary64)))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64)))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (+.f64 (log.f64 t) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (*.f64 #s(literal 1 binary64) z) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(*.f64 (pow.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) z))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) z) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) z) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) #s(literal 1 binary64)) (pow.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64)))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) #s(literal 1 binary64)) (pow.f64 (+.f64 (log.f64 t) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+.f64 (*.f64 z #s(literal 1 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))
(+.f64 (*.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))
(exp.f64 (log.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(exp.f64 (*.f64 (log.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal 1 binary64)))
(fma.f64 z #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))
(fma.f64 #s(literal 1 binary64) z (-.f64 #s(literal 0 binary64) (*.f64 z (log.f64 t))))
(neg.f64 (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 0 binary64) z)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 0 binary64) z)) #s(literal -1 binary64))
(/.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64)))))
(/.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (+.f64 (log.f64 t) #s(literal 1 binary64)))
(/.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) z) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64)))))
(/.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) z) (+.f64 (log.f64 t) #s(literal 1 binary64)))
(/.f64 (neg.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64))))))
(/.f64 (neg.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (neg.f64 (+.f64 (log.f64 t) #s(literal 1 binary64))))
(/.f64 (neg.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) z)) (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64))))))
(/.f64 (neg.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) z)) (neg.f64 (+.f64 (log.f64 t) #s(literal 1 binary64))))
(pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t))) (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t)))) #s(literal -1/2 binary64))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 z #s(literal 1 binary64)))
(*.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 0 binary64) z)))
(*.f64 #s(literal -1 binary64) (pow.f64 (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 0 binary64) z)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1/2 binary64)) (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1/2 binary64)))
(*.f64 (*.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) z)
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (pow.f64 (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)))
(*.f64 (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)) (pow.f64 (/.f64 z #s(literal 1 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 #s(literal 1 binary64) z) #s(literal 1 binary64)) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) #s(literal 1 binary64)) (pow.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)))
(*.f64 (pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64))))))
(*.f64 (pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) z) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (log.f64 t) #s(literal 1 binary64))))
(+.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 t)))
(+.f64 (-.f64 #s(literal 0 binary64) (log.f64 t)) #s(literal 1 binary64))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64))))))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 (log.f64 t) #s(literal 1 binary64))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 (log.f64 t) #s(literal 1 binary64))))
(fma.f64 #s(literal -1 binary64) (log.f64 t) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64)))) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (log.f64 t) #s(literal 1 binary64)) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64)))) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (log.f64 t) #s(literal 1 binary64)) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64)))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 t))))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 (log.f64 t) #s(literal 1 binary64)))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 t))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64))))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 t)))))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (+.f64 (log.f64 t) #s(literal 1 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (-.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (log.f64 t)))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64))))) (*.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64)))) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (*.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64)))) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64))))))
(/.f64 (-.f64 (*.f64 #s(literal 1 binary64) (+.f64 (log.f64 t) #s(literal 1 binary64))) (*.f64 (+.f64 (log.f64 t) #s(literal 1 binary64)) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (*.f64 (+.f64 (log.f64 t) #s(literal 1 binary64)) (+.f64 (log.f64 t) #s(literal 1 binary64))))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64)))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (+.f64 (log.f64 t) #s(literal 1 binary64)))))
(pow.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64)))) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (log.f64 t) #s(literal 1 binary64)) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 (log.f64 t) #s(literal 1 binary64))))))
(*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (log.f64 t) #s(literal 1 binary64))))
(*.f64 z (log.f64 t))
(*.f64 (log.f64 t) z)
(log.f64 t)
(*.f64 (log.f64 t) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 t))
(*.f64 b #s(literal -1/2 binary64))
(*.f64 #s(literal -1/2 binary64) b)
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 a)))
(pow.f64 a #s(literal 2 binary64))
(pow.f64 (*.f64 a a) #s(literal 1 binary64))
(pow.f64 (exp.f64 (log.f64 a)) #s(literal 2 binary64))
(*.f64 a a)
(*.f64 (exp.f64 (log.f64 a)) (exp.f64 (log.f64 a)))
(+.f64 a #s(literal 1/2 binary64))
(+.f64 #s(literal 1/2 binary64) a)
(-.f64 (/.f64 (*.f64 a a) (+.f64 a #s(literal -1/2 binary64))) (/.f64 #s(literal 1/4 binary64) (+.f64 a #s(literal -1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64)) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64)) (+.f64 #s(literal 1/4 binary64) (-.f64 (*.f64 a a) (*.f64 a #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 a #s(literal -1/2 binary64)))
(/.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (neg.f64 (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (neg.f64 (+.f64 #s(literal 1/4 binary64) (-.f64 (*.f64 a a) (*.f64 a #s(literal 1/2 binary64))))))
(/.f64 (neg.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (neg.f64 (+.f64 a #s(literal -1/2 binary64))))
(/.f64 (-.f64 #s(literal 1/4 binary64) (*.f64 a a)) (-.f64 #s(literal 1/2 binary64) a))
(/.f64 (-.f64 (*.f64 (*.f64 a a) (+.f64 a #s(literal -1/2 binary64))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) #s(literal 1/4 binary64))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64)))) (neg.f64 (neg.f64 (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))) (neg.f64 (neg.f64 (+.f64 a #s(literal -1/2 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 1/4 binary64) (*.f64 a a))) (neg.f64 (-.f64 #s(literal 1/2 binary64) a)))
(pow.f64 (/.f64 (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64))))))
(*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64))))

simplify595.0ms (4.7%)

Memory
-12.1MiB live, 1 015.9MiB allocated
Algorithm
1×egg-herbie
Rules
17 122×accelerator-lowering-fma.f32
17 122×accelerator-lowering-fma.f64
5 500×*-lowering-*.f32
5 500×*-lowering-*.f64
4 176×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
02433660
17533625
223043571
082363301
Stop Event
1×iter limit
1×node limit
Counts
444 → 444
Calls
Call 1
Inputs
(- (+ y (+ z (* -1/2 b))) (* z (log t)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
x
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (/ z x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (/ z x)))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (/ z x)))) (/ (* z (log t)) x)))
x
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* -1/2 b))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* -1/2 b))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* -1/2 b))) (* z (log t))) x)) 1)))
(- (+ x (+ z (* -1/2 b))) (* z (log t)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
y
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (/ z y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (/ z y)))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (/ z y)))) (/ (* z (log t)) y)))
y
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* -1/2 b))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* -1/2 b))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* -1/2 b))) (* z (log t))) y)) 1)))
(+ x (+ y (* -1/2 b)))
(+ x (+ y (+ (* -1/2 b) (* z (- 1 (log t))))))
(+ x (+ y (+ (* -1/2 b) (* z (- 1 (log t))))))
(+ x (+ y (+ (* -1/2 b) (* z (- 1 (log t))))))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (/ y z)))) (log t)))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (/ y z)))) (log t)))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (/ y z)))) (log t)))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* -1/2 b))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* -1/2 b))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* -1/2 b))) z)) (+ 1 (* -1 (log t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(* -1/2 b)
(* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(* -1/2 b)
(* -1 (* b (+ 1/2 (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(* -1 (* b (+ 1/2 (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(* -1 (* b (+ 1/2 (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(- (+ y z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
x
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
x
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(- (+ x z) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
y
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(+ x y)
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+ x (+ y (* z (- 1 (log t)))))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+ y z)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
x
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+ x z)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
y
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+ x y)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
y
(+ x y)
(+ x y)
(+ x y)
x
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
x
(+ x y)
(+ x y)
(+ x y)
y
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
x
x
x
x
x
x
x
x
x
x
x
x
(/ 1 x)
(/ 1 x)
(/ 1 x)
(/ 1 x)
(/ 1 x)
(/ 1 x)
(/ 1 x)
(/ 1 x)
(/ 1 x)
(/ 1 x)
(/ 1 x)
(/ 1 x)
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(+ x (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a)))
(+ x (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a)))
(+ x (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a)))
x
(* x (+ 1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))))
(* x (+ 1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))))
(* x (+ 1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))))
x
(* -1 (* x (- (* -1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))) 1)))
(* -1 (* x (- (* -1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))) 1)))
(* -1 (* x (- (* -1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))) 1)))
(+ x (* -1/2 b))
(+ x (+ (* -1/2 b) (* a b)))
(+ x (+ (* -1/2 b) (* a b)))
(+ x (+ (* -1/2 b) (* a b)))
(* a b)
(* a (- (+ b (/ x a)) (* 1/2 (/ b a))))
(* a (- (+ b (/ x a)) (* 1/2 (/ b a))))
(* a (- (+ b (/ x a)) (* 1/2 (/ b a))))
(* a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))
x
(+ x (* b (- (/ (pow a 2) (+ 1/2 a)) (* 1/4 (/ 1 (+ 1/2 a))))))
(+ x (* b (- (/ (pow a 2) (+ 1/2 a)) (* 1/4 (/ 1 (+ 1/2 a))))))
(+ x (* b (- (/ (pow a 2) (+ 1/2 a)) (* 1/4 (/ 1 (+ 1/2 a))))))
(* b (- (/ (pow a 2) (+ 1/2 a)) (* 1/4 (/ 1 (+ 1/2 a)))))
(* b (- (+ (/ x b) (/ (pow a 2) (+ 1/2 a))) (* 1/4 (/ 1 (+ 1/2 a)))))
(* b (- (+ (/ x b) (/ (pow a 2) (+ 1/2 a))) (* 1/4 (/ 1 (+ 1/2 a)))))
(* b (- (+ (/ x b) (/ (pow a 2) (+ 1/2 a))) (* 1/4 (/ 1 (+ 1/2 a)))))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(* -1 (* b (+ (* -1 (/ x b)) (* -1 (/ (- (pow a 2) 1/4) (+ 1/2 a))))))
(* -1 (* b (+ (* -1 (/ x b)) (* -1 (/ (- (pow a 2) 1/4) (+ 1/2 a))))))
(* -1 (* b (+ (* -1 (/ x b)) (* -1 (/ (- (pow a 2) 1/4) (+ 1/2 a))))))
(* -1/2 b)
(+ (* -1/2 b) (* a b))
(+ (* -1/2 b) (* a b))
(+ (* -1/2 b) (* a b))
(* a b)
(* a (+ b (* -1/2 (/ b a))))
(* a (+ b (* -1/2 (/ b a))))
(* a (+ b (* -1/2 (/ b a))))
(* a b)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(* -1/4 b)
(+ (* -1/4 b) (* (pow a 2) b))
(+ (* -1/4 b) (* (pow a 2) b))
(+ (* -1/4 b) (* (pow a 2) b))
(* (pow a 2) b)
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(* (pow a 2) b)
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(* b (- (pow a 2) 1/4))
(* b (- (pow a 2) 1/4))
(* b (- (pow a 2) 1/4))
(* b (- (pow a 2) 1/4))
(* b (- (pow a 2) 1/4))
(* b (- (pow a 2) 1/4))
(* b (- (pow a 2) 1/4))
(* b (- (pow a 2) 1/4))
(* b (- (pow a 2) 1/4))
(* b (- (pow a 2) 1/4))
(* b (- (pow a 2) 1/4))
(* b (- (pow a 2) 1/4))
-1/4
(- (pow a 2) 1/4)
(- (pow a 2) 1/4)
(- (pow a 2) 1/4)
(pow a 2)
(* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))
(* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))
(* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))
(pow a 2)
(* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))
(* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))
(* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (* -1 (log (/ 1 t))))))
(/ 1 (* z (- 1 (* -1 (log (/ 1 t))))))
(/ 1 (* z (- 1 (* -1 (log (/ 1 t))))))
(/ 1 (* z (- 1 (* -1 (log (/ 1 t))))))
(/ 1 (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))))
(/ 1 (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))))
(/ 1 (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))))
(/ 1 (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(- 1 (log t))
(- 1 (log t))
(- 1 (log t))
(- 1 (log t))
(- 1 (* -1 (log (/ 1 t))))
(- 1 (* -1 (log (/ 1 t))))
(- 1 (* -1 (log (/ 1 t))))
(- 1 (* -1 (log (/ 1 t))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* z (log t))
(* -1 (* z (log (/ 1 t))))
(* -1 (* z (log (/ 1 t))))
(* -1 (* z (log (/ 1 t))))
(* -1 (* z (log (/ 1 t))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(log t)
(log t)
(log t)
(log t)
(* -1 (log (/ 1 t)))
(* -1 (log (/ 1 t)))
(* -1 (log (/ 1 t)))
(* -1 (log (/ 1 t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(+ (log -1) (* -1 (log (/ -1 t))))
(+ (log -1) (* -1 (log (/ -1 t))))
(+ (log -1) (* -1 (log (/ -1 t))))
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
1/2
(+ 1/2 a)
(+ 1/2 a)
(+ 1/2 a)
a
(* a (+ 1 (* 1/2 (/ 1 a))))
(* a (+ 1 (* 1/2 (/ 1 a))))
(* a (+ 1 (* 1/2 (/ 1 a))))
a
(* a (+ 1 (* 1/2 (/ 1 a))))
(* a (+ 1 (* 1/2 (/ 1 a))))
(* a (+ 1 (* 1/2 (/ 1 a))))
Outputs
(- (+ y (+ z (* -1/2 b))) (* z (log t)))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
x
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (/ z x)))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/2 binary64) b) x)) (*.f64 z (/.f64 (log.f64 t) x)))))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (/ z x)))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/2 binary64) b) x)) (*.f64 z (/.f64 (log.f64 t) x)))))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (/ z x)))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/2 binary64) b) x)) (*.f64 z (/.f64 (log.f64 t) x)))))
x
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* -1/2 b))) (* z (log t))) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) x)) x)
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* -1/2 b))) (* z (log t))) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) x)) x)
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* -1/2 b))) (* z (log t))) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) x)) x)
(- (+ x (+ z (* -1/2 b))) (* z (log t)))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
y
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (/ z y)))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/2 binary64) b) y)) (*.f64 z (/.f64 (log.f64 t) y)))))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (/ z y)))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/2 binary64) b) y)) (*.f64 z (/.f64 (log.f64 t) y)))))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (/ z y)))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 #s(literal -1/2 binary64) b) y)) (*.f64 z (/.f64 (log.f64 t) y)))))
y
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* -1/2 b))) (* z (log t))) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) y)) y)
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* -1/2 b))) (* z (log t))) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) y)) y)
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* -1/2 b))) (* z (log t))) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) y)) y)
(+ x (+ y (* -1/2 b)))
(+.f64 x (+.f64 y (*.f64 #s(literal -1/2 binary64) b)))
(+ x (+ y (+ (* -1/2 b) (* z (- 1 (log t))))))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(+ x (+ y (+ (* -1/2 b) (* z (- 1 (log t))))))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(+ x (+ y (+ (* -1/2 b) (* z (- 1 (log t))))))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (/ y z)))) (log t)))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 (/.f64 y z) (+.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) b) z) (/.f64 x z)))))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (/ y z)))) (log t)))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 (/.f64 y z) (+.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) b) z) (/.f64 x z)))))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (/ y z)))) (log t)))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 (/.f64 y z) (+.f64 (/.f64 (*.f64 #s(literal -1/2 binary64) b) z) (/.f64 x z)))))
(* z (+ 1 (* -1 (log t))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* -1/2 b))) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 (+.f64 x (+.f64 y (*.f64 #s(literal -1/2 binary64) b))) z)))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* -1/2 b))) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 (+.f64 x (+.f64 y (*.f64 #s(literal -1/2 binary64) b))) z)))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* -1/2 b))) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 (+.f64 x (+.f64 y (*.f64 #s(literal -1/2 binary64) b))) z)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x (+.f64 y (*.f64 #s(literal -1/2 binary64) b))) (*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x (+.f64 y (*.f64 #s(literal -1/2 binary64) b))) (*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x (+.f64 y (*.f64 #s(literal -1/2 binary64) b))) (*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x (+.f64 y (*.f64 #s(literal -1/2 binary64) b))) (*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 y (+.f64 (*.f64 #s(literal -1/2 binary64) b) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (/.f64 x b) (+.f64 (/.f64 z b) (-.f64 (-.f64 (/.f64 y b) #s(literal 1/2 binary64)) (*.f64 z (/.f64 (log.f64 t) b))))))
(* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (/.f64 x b) (+.f64 (/.f64 z b) (-.f64 (-.f64 (/.f64 y b) #s(literal 1/2 binary64)) (*.f64 z (/.f64 (log.f64 t) b))))))
(* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (/.f64 x b) (+.f64 (/.f64 z b) (-.f64 (-.f64 (/.f64 y b) #s(literal 1/2 binary64)) (*.f64 z (/.f64 (log.f64 t) b))))))
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(* -1 (* b (+ 1/2 (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 (-.f64 #s(literal 1/2 binary64) (/.f64 (+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) b)) (-.f64 #s(literal 0 binary64) b))
(* -1 (* b (+ 1/2 (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 (-.f64 #s(literal 1/2 binary64) (/.f64 (+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) b)) (-.f64 #s(literal 0 binary64) b))
(* -1 (* b (+ 1/2 (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 (-.f64 #s(literal 1/2 binary64) (/.f64 (+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))) b)) (-.f64 #s(literal 0 binary64) b))
(- (+ y z) (* z (log t)))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
x
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 (/.f64 z x) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 y x)) (*.f64 z (/.f64 (log.f64 t) x)))))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 (/.f64 z x) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 y x)) (*.f64 z (/.f64 (log.f64 t) x)))))
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(*.f64 x (+.f64 (/.f64 z x) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 y x)) (*.f64 z (/.f64 (log.f64 t) x)))))
x
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x)) x)
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x)) x)
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) x)) x)
(- (+ x z) (* z (log t)))
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
y
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 x y)) (-.f64 (/.f64 z y) (*.f64 z (/.f64 (log.f64 t) y)))))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 x y)) (-.f64 (/.f64 z y) (*.f64 z (/.f64 (log.f64 t) y)))))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(*.f64 y (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 x y)) (-.f64 (/.f64 z y) (*.f64 z (/.f64 (log.f64 t) y)))))
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) y)) y)
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) y)) y)
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) y)) y)
(+ x y)
(+.f64 y x)
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(*.f64 z (+.f64 #s(literal 1 binary64) (-.f64 (+.f64 (/.f64 x z) (/.f64 y z)) (log.f64 t))))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(*.f64 z (+.f64 #s(literal 1 binary64) (-.f64 (+.f64 (/.f64 x z) (/.f64 y z)) (log.f64 t))))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(*.f64 z (+.f64 #s(literal 1 binary64) (-.f64 (+.f64 (/.f64 x z) (/.f64 y z)) (log.f64 t))))
(* z (+ 1 (* -1 (log t))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 x (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 y (+.f64 x (*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 y (+.f64 x (*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 y (+.f64 x (*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 y (+.f64 x (*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))))
(+ y z)
(+.f64 y z)
(+ x (+ y z))
(+.f64 z (+.f64 y x))
(+ x (+ y z))
(+.f64 z (+.f64 y x))
(+ x (+ y z))
(+.f64 z (+.f64 y x))
x
(* x (+ 1 (+ (/ y x) (/ z x))))
(*.f64 x (+.f64 (/.f64 y x) (+.f64 #s(literal 1 binary64) (/.f64 z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
(*.f64 x (+.f64 (/.f64 y x) (+.f64 #s(literal 1 binary64) (/.f64 z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
(*.f64 x (+.f64 (/.f64 y x) (+.f64 #s(literal 1 binary64) (/.f64 z x))))
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y z) x)) x)
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y z) x)) x)
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y z) x)) x)
(+ x z)
(+.f64 z x)
(+ x (+ y z))
(+.f64 z (+.f64 y x))
(+ x (+ y z))
(+.f64 z (+.f64 y x))
(+ x (+ y z))
(+.f64 z (+.f64 y x))
y
(* y (+ 1 (+ (/ x y) (/ z y))))
(*.f64 y (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 x y) (/.f64 z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
(*.f64 y (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 x y) (/.f64 z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
(*.f64 y (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 x y) (/.f64 z y))))
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z x) y)) y)
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z x) y)) y)
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z x) y)) y)
(+ x y)
(+.f64 y x)
(+ x (+ y z))
(+.f64 z (+.f64 y x))
(+ x (+ y z))
(+.f64 z (+.f64 y x))
(+ x (+ y z))
(+.f64 z (+.f64 y x))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 x z) (/.f64 y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 x z) (/.f64 y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (/.f64 x z) (/.f64 y z))))
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y x) z)) z)
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y x) z)) z)
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y x) z)) z)
y
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
x
(* x (+ 1 (/ y x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 y x)))
(* x (+ 1 (/ y x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 y x)))
(* x (+ 1 (/ y x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 y x)))
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 y x)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 y x)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 y x)))
x
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
y
(* y (+ 1 (/ x y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 x y)))
(* y (+ 1 (/ x y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 x y)))
(* y (+ 1 (/ x y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 x y)))
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 x y)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 x y)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 x y)))
x
x
x
x
x
x
x
x
x
x
x
x
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(/ 1 x)
(/.f64 #s(literal 1 binary64) x)
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(+ x (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a)))
(+.f64 x (/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a)))
(+ x (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a)))
(+.f64 x (/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a)))
(+ x (/ (* b (- (pow a 2) 1/4)) (+ 1/2 a)))
(+.f64 x (/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a)))
x
(* x (+ 1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 (/.f64 b x) (/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 #s(literal 1/2 binary64) a)))))
(* x (+ 1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 (/.f64 b x) (/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 #s(literal 1/2 binary64) a)))))
(* x (+ 1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 (/.f64 b x) (/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 #s(literal 1/2 binary64) a)))))
x
(* -1 (* x (- (* -1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))) 1)))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 (/.f64 b x) (/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 #s(literal 1/2 binary64) a)))))
(* -1 (* x (- (* -1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))) 1)))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 (/.f64 b x) (/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 #s(literal 1/2 binary64) a)))))
(* -1 (* x (- (* -1 (/ (* b (- (pow a 2) 1/4)) (* x (+ 1/2 a)))) 1)))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 (/.f64 b x) (/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 #s(literal 1/2 binary64) a)))))
(+ x (* -1/2 b))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
(+ x (+ (* -1/2 b) (* a b)))
(+.f64 x (*.f64 b (+.f64 #s(literal -1/2 binary64) a)))
(+ x (+ (* -1/2 b) (* a b)))
(+.f64 x (*.f64 b (+.f64 #s(literal -1/2 binary64) a)))
(+ x (+ (* -1/2 b) (* a b)))
(+.f64 x (*.f64 b (+.f64 #s(literal -1/2 binary64) a)))
(* a b)
(*.f64 b a)
(* a (- (+ b (/ x a)) (* 1/2 (/ b a))))
(-.f64 (*.f64 b a) (*.f64 (-.f64 (*.f64 b #s(literal 1/2 binary64)) x) #s(literal 1 binary64)))
(* a (- (+ b (/ x a)) (* 1/2 (/ b a))))
(-.f64 (*.f64 b a) (*.f64 (-.f64 (*.f64 b #s(literal 1/2 binary64)) x) #s(literal 1 binary64)))
(* a (- (+ b (/ x a)) (* 1/2 (/ b a))))
(-.f64 (*.f64 b a) (*.f64 (-.f64 (*.f64 b #s(literal 1/2 binary64)) x) #s(literal 1 binary64)))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))
(-.f64 (*.f64 b a) (*.f64 (-.f64 (*.f64 b #s(literal 1/2 binary64)) x) #s(literal 1 binary64)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))
(-.f64 (*.f64 b a) (*.f64 (-.f64 (*.f64 b #s(literal 1/2 binary64)) x) #s(literal 1 binary64)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))
(-.f64 (*.f64 b a) (*.f64 (-.f64 (*.f64 b #s(literal 1/2 binary64)) x) #s(literal 1 binary64)))
x
(+ x (* b (- (/ (pow a 2) (+ 1/2 a)) (* 1/4 (/ 1 (+ 1/2 a))))))
(+.f64 x (/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a)))
(+ x (* b (- (/ (pow a 2) (+ 1/2 a)) (* 1/4 (/ 1 (+ 1/2 a))))))
(+.f64 x (/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a)))
(+ x (* b (- (/ (pow a 2) (+ 1/2 a)) (* 1/4 (/ 1 (+ 1/2 a))))))
(+.f64 x (/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a)))
(* b (- (/ (pow a 2) (+ 1/2 a)) (* 1/4 (/ 1 (+ 1/2 a)))))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(* b (- (+ (/ x b) (/ (pow a 2) (+ 1/2 a))) (* 1/4 (/ 1 (+ 1/2 a)))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 #s(literal 1/2 binary64) a))))
(* b (- (+ (/ x b) (/ (pow a 2) (+ 1/2 a))) (* 1/4 (/ 1 (+ 1/2 a)))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 #s(literal 1/2 binary64) a))))
(* b (- (+ (/ x b) (/ (pow a 2) (+ 1/2 a))) (* 1/4 (/ 1 (+ 1/2 a)))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 #s(literal 1/2 binary64) a))))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(* -1 (* b (+ (* -1 (/ x b)) (* -1 (/ (- (pow a 2) 1/4) (+ 1/2 a))))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 #s(literal 1/2 binary64) a))))
(* -1 (* b (+ (* -1 (/ x b)) (* -1 (/ (- (pow a 2) 1/4) (+ 1/2 a))))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 #s(literal 1/2 binary64) a))))
(* -1 (* b (+ (* -1 (/ x b)) (* -1 (/ (- (pow a 2) 1/4) (+ 1/2 a))))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (+.f64 #s(literal 1/2 binary64) a))))
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(+ (* -1/2 b) (* a b))
(*.f64 b (+.f64 #s(literal -1/2 binary64) a))
(+ (* -1/2 b) (* a b))
(*.f64 b (+.f64 #s(literal -1/2 binary64) a))
(+ (* -1/2 b) (* a b))
(*.f64 b (+.f64 #s(literal -1/2 binary64) a))
(* a b)
(*.f64 b a)
(* a (+ b (* -1/2 (/ b a))))
(*.f64 b (+.f64 #s(literal -1/2 binary64) a))
(* a (+ b (* -1/2 (/ b a))))
(*.f64 b (+.f64 #s(literal -1/2 binary64) a))
(* a (+ b (* -1/2 (/ b a))))
(*.f64 b (+.f64 #s(literal -1/2 binary64) a))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 b (+.f64 #s(literal -1/2 binary64) a))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 b (+.f64 #s(literal -1/2 binary64) a))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 b (+.f64 #s(literal -1/2 binary64) a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* b (- (pow a 2) 1/4)) (+ 1/2 a))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 #s(literal 1/2 binary64) a))
(* -1/4 b)
(*.f64 b #s(literal -1/4 binary64))
(+ (* -1/4 b) (* (pow a 2) b))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(+ (* -1/4 b) (* (pow a 2) b))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(+ (* -1/4 b) (* (pow a 2) b))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(* (pow a 2) b)
(*.f64 b (*.f64 a a))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))
(* (pow a 2) b)
(*.f64 b (*.f64 a a))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))
(* b (- (pow a 2) 1/4))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(* b (- (pow a 2) 1/4))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(* b (- (pow a 2) 1/4))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(* b (- (pow a 2) 1/4))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(* b (- (pow a 2) 1/4))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(* b (- (pow a 2) 1/4))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(* b (- (pow a 2) 1/4))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(* b (- (pow a 2) 1/4))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(* b (- (pow a 2) 1/4))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(* b (- (pow a 2) 1/4))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(* b (- (pow a 2) 1/4))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(* b (- (pow a 2) 1/4))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
-1/4
#s(literal -1/4 binary64)
(- (pow a 2) 1/4)
(+.f64 (*.f64 a a) #s(literal -1/4 binary64))
(- (pow a 2) 1/4)
(+.f64 (*.f64 a a) #s(literal -1/4 binary64))
(- (pow a 2) 1/4)
(+.f64 (*.f64 a a) #s(literal -1/4 binary64))
(pow a 2)
(*.f64 a a)
(* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(pow a 2)
(*.f64 a a)
(* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (* -1 (log (/ 1 t))))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (* -1 (log (/ 1 t))))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (* -1 (log (/ 1 t))))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (* -1 (log (/ 1 t))))))
(/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(/ 1 (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))))
(/.f64 (/.f64 #s(literal 1 binary64) z) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))
(/ 1 (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))))
(/.f64 (/.f64 #s(literal 1 binary64) z) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))
(/ 1 (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))))
(/.f64 (/.f64 #s(literal 1 binary64) z) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))
(/ 1 (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))))
(/.f64 (/.f64 #s(literal 1 binary64) z) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64)))))
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (* -1 (log (/ 1 t))))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (* -1 (log (/ 1 t))))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (* -1 (log (/ 1 t))))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (* -1 (log (/ 1 t))))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(+.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* z (log t))
(*.f64 z (log.f64 t))
(* -1 (* z (log (/ 1 t))))
(*.f64 z (log.f64 t))
(* -1 (* z (log (/ 1 t))))
(*.f64 z (log.f64 t))
(* -1 (* z (log (/ 1 t))))
(*.f64 z (log.f64 t))
(* -1 (* z (log (/ 1 t))))
(*.f64 z (log.f64 t))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* z (+ (log -1) (* -1 (log (/ -1 t)))))
(*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(log t)
(log.f64 t)
(log t)
(log.f64 t)
(log t)
(log.f64 t)
(log t)
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
1/2
#s(literal 1/2 binary64)
(+ 1/2 a)
(+.f64 #s(literal 1/2 binary64) a)
(+ 1/2 a)
(+.f64 #s(literal 1/2 binary64) a)
(+ 1/2 a)
(+.f64 #s(literal 1/2 binary64) a)
a
(* a (+ 1 (* 1/2 (/ 1 a))))
(+.f64 #s(literal 1/2 binary64) a)
(* a (+ 1 (* 1/2 (/ 1 a))))
(+.f64 #s(literal 1/2 binary64) a)
(* a (+ 1 (* 1/2 (/ 1 a))))
(+.f64 #s(literal 1/2 binary64) a)
a
(* a (+ 1 (* 1/2 (/ 1 a))))
(+.f64 #s(literal 1/2 binary64) a)
(* a (+ 1 (* 1/2 (/ 1 a))))
(+.f64 #s(literal 1/2 binary64) a)
(* a (+ 1 (* 1/2 (/ 1 a))))
(+.f64 #s(literal 1/2 binary64) a)

eval143.0ms (1.1%)

Memory
38.7MiB live, 342.0MiB allocated
Compiler

Compiled 25 907 to 2 680 computations (89.7% saved)

prune190.0ms (1.5%)

Memory
-11.6MiB live, 474.5MiB allocated
Pruning

41 alts after pruning (36 fresh and 5 done)

PrunedKeptTotal
New1 155161 171
Fresh72027
Picked235
Done022
Total1 164411 205
Accuracy
100.0%
Counts
1 205 → 41
Alt Table
Click to see full alt table
StatusAccuracyProgram
16.7%
(/.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 x x)) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))
23.1%
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (/.f64 #s(literal 1 binary64) x)))
21.5%
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) z))
37.2%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
24.3%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
✓20.1%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
✓77.2%
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
54.1%
(+.f64 (-.f64 (+.f64 z x) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
35.1%
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
✓62.9%
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
▶33.5%
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
60.2%
(+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
44.0%
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
37.6%
(+.f64 y (*.f64 b #s(literal -1/2 binary64)))
42.6%
(+.f64 y x)
28.1%
(+.f64 x (/.f64 (/.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))) (+.f64 a #s(literal 1/2 binary64))))
32.7%
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64))))))
37.5%
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64))))))
30.0%
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) a))
35.2%
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) #s(literal 1/2 binary64)))
36.3%
(+.f64 x (/.f64 (*.f64 (*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) b) (+.f64 a #s(literal 1/2 binary64))))
▶30.7%
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
33.2%
(+.f64 x (/.f64 (*.f64 b #s(literal -1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))))
40.1%
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
42.2%
(+.f64 x (*.f64 b a))
21.5%
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (-.f64 #s(literal 1 binary64) (log.f64 t)))
16.6%
(*.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
▶21.5%
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
▶73.3%
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t))))) b)
19.0%
(*.f64 (*.f64 z b) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))
50.1%
(*.f64 x (+.f64 (/.f64 y x) (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) #s(literal 1 binary64))))
15.1%
(*.f64 b (/.f64 y b))
13.8%
(*.f64 b (/.f64 x b))
49.1%
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
37.3%
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
12.3%
(*.f64 b (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
24.4%
(*.f64 b a)
71.4%
(*.f64 a (+.f64 (+.f64 b (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (*.f64 z (/.f64 (log.f64 t) a)))))
▶15.3%
(*.f64 #s(literal -1/2 binary64) b)
✓24.4%
y
✓20.2%
x
Compiler

Compiled 1 457 to 979 computations (32.8% saved)

simplify399.0ms (3.1%)

Memory
-31.2MiB live, 554.1MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 14 expressions of interest:

NewMetricScoreProgram
✓cost-diff0
(log.f64 t)
✓cost-diff0
(-.f64 #s(literal 1 binary64) (log.f64 t))
✓cost-diff0
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
✓cost-diff0
(*.f64 a a)
✓cost-diff0
(/.f64 (*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64)))
✓cost-diff0
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
✓cost-diff384
(*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))
✓cost-diff0
(*.f64 #s(literal -1/2 binary64) b)
✓cost-diff0
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
✓cost-diff0
(*.f64 #s(literal -1/2 binary64) b)
✓cost-diff0
(+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))
✓cost-diff128
(*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))
✓cost-diff128
(+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t)))))
✓cost-diff256
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t))))) b)
Rules
11 866×accelerator-lowering-fma.f32
11 866×accelerator-lowering-fma.f64
3 362×+-lowering-+.f64
3 362×+-lowering-+.f32
2 984×*-lowering-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
034218
186210
2240210
3695188
42187184
55594184
08717174
Stop Event
1×iter limit
1×node limit
Calls
Call 1
Inputs
(* (+ (+ a (+ -1/2 (/ z b))) (- (* (/ 1 b) (+ x y)) (/ z (/ b (log t))))) b)
(+ (+ a (+ -1/2 (/ z b))) (- (* (/ 1 b) (+ x y)) (/ z (/ b (log t)))))
(+ a (+ -1/2 (/ z b)))
a
(+ -1/2 (/ z b))
-1/2
(/ z b)
z
b
(- (* (/ 1 b) (+ x y)) (/ z (/ b (log t))))
(* (/ 1 b) (+ x y))
(/ 1 b)
1
(+ x y)
x
y
(/ z (/ b (log t)))
(/ b (log t))
(log t)
t
(* -1/2 b)
-1/2
b
(+ (* -1/2 b) x)
(* -1/2 b)
-1/2
b
x
(+ x (/ (* (* a a) (+ b (/ (* b -1/4) (* a a)))) (+ a 1/2)))
x
(/ (* (* a a) (+ b (/ (* b -1/4) (* a a)))) (+ a 1/2))
(* (* a a) (+ b (/ (* b -1/4) (* a a))))
(* a a)
a
(+ b (/ (* b -1/4) (* a a)))
b
(/ (* b -1/4) (* a a))
(* b -1/4)
-1/4
(+ a 1/2)
1/2
(* (- 1 (log t)) z)
(- 1 (log t))
1
(log t)
t
z
Outputs
(* (+ (+ a (+ -1/2 (/ z b))) (- (* (/ 1 b) (+ x y)) (/ z (/ b (log t))))) b)
(+.f64 (+.f64 (+.f64 x y) (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(+ (+ a (+ -1/2 (/ z b))) (- (* (/ 1 b) (+ x y)) (/ z (/ b (log t)))))
(+.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 x y) (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z))))
(+ a (+ -1/2 (/ z b)))
(+.f64 #s(literal -1/2 binary64) (+.f64 a (/.f64 z b)))
a
(+ -1/2 (/ z b))
(+.f64 #s(literal -1/2 binary64) (/.f64 z b))
-1/2
#s(literal -1/2 binary64)
(/ z b)
(/.f64 z b)
z
b
(- (* (/ 1 b) (+ x y)) (/ z (/ b (log t))))
(*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (-.f64 y (*.f64 (log.f64 t) z)) x))
(* (/ 1 b) (+ x y))
(/.f64 (+.f64 x y) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
1
#s(literal 1 binary64)
(+ x y)
(+.f64 x y)
x
y
(/ z (/ b (log t)))
(/.f64 (*.f64 (log.f64 t) z) b)
(/ b (log t))
(/.f64 b (log.f64 t))
(log t)
(log.f64 t)
t
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
-1/2
#s(literal -1/2 binary64)
b
(+ (* -1/2 b) x)
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
(* -1/2 b)
(*.f64 #s(literal -1/2 binary64) b)
-1/2
#s(literal -1/2 binary64)
b
x
(+ x (/ (* (* a a) (+ b (/ (* b -1/4) (* a a)))) (+ a 1/2)))
(+.f64 (/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 a #s(literal 1/2 binary64))) x)
x
(/ (* (* a a) (+ b (/ (* b -1/4) (* a a)))) (+ a 1/2))
(/.f64 (*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 a #s(literal 1/2 binary64)))
(* (* a a) (+ b (/ (* b -1/4) (* a a))))
(*.f64 b (+.f64 (*.f64 a a) #s(literal -1/4 binary64)))
(* a a)
(*.f64 a a)
a
(+ b (/ (* b -1/4) (* a a)))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
b
(/ (* b -1/4) (* a a))
(/.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) a) a)
(* b -1/4)
(*.f64 b #s(literal -1/4 binary64))
-1/4
#s(literal -1/4 binary64)
(+ a 1/2)
(+.f64 a #s(literal 1/2 binary64))
1/2
#s(literal 1/2 binary64)
(* (- 1 (log t)) z)
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
1
#s(literal 1 binary64)
(log t)
(log.f64 t)
t
z

localize124.0ms (1%)

Memory
4.5MiB live, 239.0MiB allocated
Localize:

Found 14 expressions of interest:

NewMetricScoreProgram
✓accuracy100.0%
(log.f64 t)
✓accuracy100.0%
(-.f64 #s(literal 1 binary64) (log.f64 t))
✓accuracy99.6%
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
✓accuracy100.0%
(+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))
✓accuracy88.5%
(/.f64 (*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64)))
✓accuracy87.6%
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
✓accuracy66.3%
(*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))
✓accuracy100.0%
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
✓accuracy100.0%
(*.f64 #s(literal -1/2 binary64) b)
✓accuracy100.0%
(*.f64 #s(literal -1/2 binary64) b)
✓accuracy99.6%
(/.f64 b (log.f64 t))
✓accuracy96.5%
(-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t))))
✓accuracy92.7%
(+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t)))))
✓accuracy74.1%
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t))))) b)
Samples
81.0ms256×0valid
Compiler

Compiled 220 to 36 computations (83.6% saved)

Precisions
Click to see histograms. Total time spent on operations: 39.0ms
ival-add: 12.0ms (30.9% of total)
ival-div: 10.0ms (25.8% of total)
ival-mult: 10.0ms (25.8% of total)
ival-log: 3.0ms (7.7% of total)
ival-sub: 2.0ms (5.2% of total)
ival-true: 0.0ms (0% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

series41.0ms (0.3%)

Memory
-10.1MiB live, 102.2MiB allocated
Counts
17 → 528
Calls
Call 1
Inputs
#<alt (* (+ (+ a (+ -1/2 (/ z b))) (- (* (/ 1 b) (+ x y)) (/ z (/ b (log t))))) b)>
#<alt (+ (+ a (+ -1/2 (/ z b))) (- (* (/ 1 b) (+ x y)) (/ z (/ b (log t)))))>
#<alt (* (/ 1 b) (+ x y))>
#<alt (+ a (+ -1/2 (/ z b)))>
#<alt (* -1/2 b)>
#<alt (+ (* -1/2 b) x)>
#<alt (* (* a a) (+ b (/ (* b -1/4) (* a a))))>
#<alt (+ x (/ (* (* a a) (+ b (/ (* b -1/4) (* a a)))) (+ a 1/2)))>
#<alt (/ (* (* a a) (+ b (/ (* b -1/4) (* a a)))) (+ a 1/2))>
#<alt (* a a)>
#<alt (* (- 1 (log t)) z)>
#<alt (- 1 (log t))>
#<alt (log t)>
#<alt (- (* (/ 1 b) (+ x y)) (/ z (/ b (log t))))>
#<alt (/ b (log t))>
#<alt (/ (* b -1/4) (* a a))>
#<alt (+ b (/ (* b -1/4) (* a a)))>
Outputs
#<alt (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (* a b)>
#<alt (* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))>
#<alt (* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))>
#<alt (* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))>
#<alt (* b (- (+ a (+ (/ x b) (/ y b))) 1/2))>
#<alt (+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))>
#<alt (+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))>
#<alt (+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))>
#<alt (* b (* z (- (/ 1 b) (/ (log t) b))))>
#<alt (* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))>
#<alt (* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))>
#<alt (* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))>
#<alt (* b (* z (+ (* -1 (/ (log t) b)) (/ 1 b))))>
#<alt (* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))>
#<alt (* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))>
#<alt (* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))>
#<alt (- (+ x (+ y z)) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))>
#<alt (* b (- a 1/2))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- a 1/2))>
#<alt (* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ z b)) (* -1 (/ (+ x y) b)))) (* -1 (/ (* z (log t)) b)))))>
#<alt (* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ z b)) (* -1 (/ (+ x y) b)))) (* -1 (/ (* z (log t)) b)))))>
#<alt (* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ z b)) (* -1 (/ (+ x y) b)))) (* -1 (/ (* z (log t)) b)))))>
#<alt (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt x>
#<alt (* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))>
#<alt (* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))>
#<alt (* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))>
#<alt (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt (+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))>
#<alt y>
#<alt (* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))>
#<alt (* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))>
#<alt (* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))>
#<alt (* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))>
#<alt (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt a>
#<alt (* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))>
#<alt (* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))>
#<alt (* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))>
#<alt (- (+ a (+ (/ x b) (/ y b))) 1/2)>
#<alt (- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)>
#<alt (- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)>
#<alt (- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)>
#<alt (* z (- (/ 1 b) (/ (log t) b)))>
#<alt (* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))>
#<alt (* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))>
#<alt (* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))>
#<alt (* z (+ (* -1 (/ (log t) b)) (/ 1 b)))>
#<alt (* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))>
#<alt (* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))>
#<alt (* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))>
#<alt (/ (- (+ x (+ y z)) (* z (log t))) b)>
#<alt (/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)>
#<alt (/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)>
#<alt (/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)>
#<alt (- a 1/2)>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- a 1/2)>
#<alt (- (+ a (* -1 (/ (- (+ (* -1 z) (* -1 (+ x y))) (* -1 (* z (log t)))) b))) 1/2)>
#<alt (- (+ a (* -1 (/ (- (+ (* -1 z) (* -1 (+ x y))) (* -1 (* z (log t)))) b))) 1/2)>
#<alt (- (+ a (* -1 (/ (- (+ (* -1 z) (* -1 (+ x y))) (* -1 (* z (log t)))) b))) 1/2)>
#<alt (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (/ x b)>
#<alt (* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))>
#<alt (* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))>
#<alt (* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))>
#<alt (/ x b)>
#<alt (* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))>
#<alt (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (/ y b)>
#<alt (* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))>
#<alt (* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))>
#<alt (* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))>
#<alt (/ y b)>
#<alt (* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))>
#<alt (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ (+ x y) b)>
#<alt (/ y b)>
#<alt (+ (/ x b) (/ y b))>
#<alt (+ (/ x b) (/ y b))>
#<alt (+ (/ x b) (/ y b))>
#<alt (/ x b)>
#<alt (* x (+ (/ 1 b) (/ y (* b x))))>
#<alt (* x (+ (/ 1 b) (/ y (* b x))))>
#<alt (* x (+ (/ 1 b) (/ y (* b x))))>
#<alt (/ x b)>
#<alt (* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))>
#<alt (* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))>
#<alt (* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))>
#<alt (/ x b)>
#<alt (+ (/ x b) (/ y b))>
#<alt (+ (/ x b) (/ y b))>
#<alt (+ (/ x b) (/ y b))>
#<alt (/ y b)>
#<alt (* y (+ (/ 1 b) (/ x (* b y))))>
#<alt (* y (+ (/ 1 b) (/ x (* b y))))>
#<alt (* y (+ (/ 1 b) (/ x (* b y))))>
#<alt (/ y b)>
#<alt (* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))>
#<alt (* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))>
#<alt (* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))>
#<alt (- (/ z b) 1/2)>
#<alt (- (+ a (/ z b)) 1/2)>
#<alt (- (+ a (/ z b)) 1/2)>
#<alt (- (+ a (/ z b)) 1/2)>
#<alt a>
#<alt (* a (- (+ 1 (/ z (* a b))) (* 1/2 (/ 1 a))))>
#<alt (* a (- (+ 1 (/ z (* a b))) (* 1/2 (/ 1 a))))>
#<alt (* a (- (+ 1 (/ z (* a b))) (* 1/2 (/ 1 a))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (- (/ z b) 1/2) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (- (/ z b) 1/2) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (- (/ z b) 1/2) a)) 1)))>
#<alt (- a 1/2)>
#<alt (- (+ a (/ z b)) 1/2)>
#<alt (- (+ a (/ z b)) 1/2)>
#<alt (- (+ a (/ z b)) 1/2)>
#<alt (/ z b)>
#<alt (* z (- (+ (/ 1 b) (/ a z)) (* 1/2 (/ 1 z))))>
#<alt (* z (- (+ (/ 1 b) (/ a z)) (* 1/2 (/ 1 z))))>
#<alt (* z (- (+ (/ 1 b) (/ a z)) (* 1/2 (/ 1 z))))>
#<alt (/ z b)>
#<alt (* -1 (* z (- (* -1 (/ (- a 1/2) z)) (/ 1 b))))>
#<alt (* -1 (* z (- (* -1 (/ (- a 1/2) z)) (/ 1 b))))>
#<alt (* -1 (* z (- (* -1 (/ (- a 1/2) z)) (/ 1 b))))>
#<alt (/ z b)>
#<alt (/ (+ z (* b (- a 1/2))) b)>
#<alt (/ (+ z (* b (- a 1/2))) b)>
#<alt (/ (+ z (* b (- a 1/2))) b)>
#<alt (- a 1/2)>
#<alt (- (+ a (/ z b)) 1/2)>
#<alt (- (+ a (/ z b)) 1/2)>
#<alt (- (+ a (/ z b)) 1/2)>
#<alt (- a 1/2)>
#<alt (- (+ a (/ z b)) 1/2)>
#<alt (- (+ a (/ z b)) 1/2)>
#<alt (- (+ a (/ z b)) 1/2)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt (* -1/2 b)>
#<alt x>
#<alt (+ x (* -1/2 b))>
#<alt (+ x (* -1/2 b))>
#<alt (+ x (* -1/2 b))>
#<alt (* -1/2 b)>
#<alt (* b (- (/ x b) 1/2))>
#<alt (* b (- (/ x b) 1/2))>
#<alt (* b (- (/ x b) 1/2))>
#<alt (* -1/2 b)>
#<alt (* -1 (* b (+ 1/2 (* -1 (/ x b)))))>
#<alt (* -1 (* b (+ 1/2 (* -1 (/ x b)))))>
#<alt (* -1 (* b (+ 1/2 (* -1 (/ x b)))))>
#<alt (* -1/2 b)>
#<alt (+ x (* -1/2 b))>
#<alt (+ x (* -1/2 b))>
#<alt (+ x (* -1/2 b))>
#<alt x>
#<alt (* x (+ 1 (* -1/2 (/ b x))))>
#<alt (* x (+ 1 (* -1/2 (/ b x))))>
#<alt (* x (+ 1 (* -1/2 (/ b x))))>
#<alt x>
#<alt (* -1 (* x (- (* 1/2 (/ b x)) 1)))>
#<alt (* -1 (* x (- (* 1/2 (/ b x)) 1)))>
#<alt (* -1 (* x (- (* 1/2 (/ b x)) 1)))>
#<alt (* -1/4 b)>
#<alt (+ (* -1/4 b) (* (pow a 2) b))>
#<alt (+ (* -1/4 b) (* (pow a 2) b))>
#<alt (+ (* -1/4 b) (* (pow a 2) b))>
#<alt (* (pow a 2) b)>
#<alt (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))>
#<alt (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))>
#<alt (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))>
#<alt (* (pow a 2) b)>
#<alt (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))>
#<alt (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))>
#<alt (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))>
#<alt (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))>
#<alt (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))>
#<alt (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))>
#<alt (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))>
#<alt (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))>
#<alt (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))>
#<alt (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))>
#<alt (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))>
#<alt (* -1 (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))))>
#<alt (* -1 (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))))>
#<alt (* -1 (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))))>
#<alt (* -1 (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))))>
#<alt (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (+ 1/2 a))>
#<alt (+ x (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (+ 1/2 a)))>
#<alt (+ x (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (+ 1/2 a)))>
#<alt (+ x (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (+ 1/2 a)))>
#<alt x>
#<alt (* x (+ 1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))))>
#<alt (* x (+ 1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))))>
#<alt (* x (+ 1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))) 1)))>
#<alt (+ x (* -1/2 b))>
#<alt (+ x (+ (* -1/2 b) (* a b)))>
#<alt (+ x (+ (* -1/2 b) (* a b)))>
#<alt (+ x (+ (* -1/2 b) (* a b)))>
#<alt (* a b)>
#<alt (* a (- (+ b (/ x a)) (* 1/2 (/ b a))))>
#<alt (* a (- (+ b (/ x a)) (* 1/2 (/ b a))))>
#<alt (* a (- (+ b (/ x a)) (* 1/2 (/ b a))))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))>
#<alt x>
#<alt (+ x (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a)))>
#<alt (+ x (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a)))>
#<alt (+ x (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a)))>
#<alt (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))>
#<alt (* b (+ (/ x b) (/ (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2))))) (+ 1/2 a))))>
#<alt (* b (+ (/ x b) (/ (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2))))) (+ 1/2 a))))>
#<alt (* b (+ (/ x b) (/ (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2))))) (+ 1/2 a))))>
#<alt (* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))>
#<alt (* -1 (* b (+ (* -1 (/ x b)) (/ (* (pow a 2) (- (* 1/4 (/ 1 (pow a 2))) 1)) (+ 1/2 a)))))>
#<alt (* -1 (* b (+ (* -1 (/ x b)) (/ (* (pow a 2) (- (* 1/4 (/ 1 (pow a 2))) 1)) (+ 1/2 a)))))>
#<alt (* -1 (* b (+ (* -1 (/ x b)) (/ (* (pow a 2) (- (* 1/4 (/ 1 (pow a 2))) 1)) (+ 1/2 a)))))>
#<alt (* -1/2 b)>
#<alt (+ (* -1/2 b) (* a b))>
#<alt (+ (* -1/2 b) (* a b))>
#<alt (+ (* -1/2 b) (* a b))>
#<alt (* a b)>
#<alt (* a (+ b (* -1/2 (/ b a))))>
#<alt (* a (+ b (* -1/2 (/ b a))))>
#<alt (* a (+ b (* -1/2 (/ b a))))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))>
#<alt (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))>
#<alt (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))>
#<alt (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))>
#<alt (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))>
#<alt (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))>
#<alt (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))>
#<alt (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))>
#<alt (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))>
#<alt (* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))>
#<alt (* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))>
#<alt (* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))>
#<alt (* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (pow a 2)>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (* -1 (log (/ 1 t)))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- 1 (log t)))>
#<alt (- 1 (log t))>
#<alt (- 1 (log t))>
#<alt (- 1 (log t))>
#<alt (- 1 (log t))>
#<alt (- 1 (* -1 (log (/ 1 t))))>
#<alt (- 1 (* -1 (log (/ 1 t))))>
#<alt (- 1 (* -1 (log (/ 1 t))))>
#<alt (- 1 (* -1 (log (/ 1 t))))>
#<alt (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (- 1 (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (log t)>
#<alt (log t)>
#<alt (log t)>
#<alt (log t)>
#<alt (* -1 (log (/ 1 t)))>
#<alt (* -1 (log (/ 1 t)))>
#<alt (* -1 (log (/ 1 t)))>
#<alt (* -1 (log (/ 1 t)))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (+ (log -1) (* -1 (log (/ -1 t))))>
#<alt (/ (- (+ x y) (* z (log t))) b)>
#<alt (/ (- (+ x y) (* z (log t))) b)>
#<alt (/ (- (+ x y) (* z (log t))) b)>
#<alt (/ (- (+ x y) (* z (log t))) b)>
#<alt (/ (- (+ x y) (* z (log t))) b)>
#<alt (/ (- (+ x y) (* z (log t))) b)>
#<alt (/ (- (+ x y) (* z (log t))) b)>
#<alt (/ (- (+ x y) (* z (log t))) b)>
#<alt (* -1 (/ (- (* -1 (+ x y)) (* -1 (* z (log t)))) b))>
#<alt (* -1 (/ (- (* -1 (+ x y)) (* -1 (* z (log t)))) b))>
#<alt (* -1 (/ (- (* -1 (+ x y)) (* -1 (* z (log t)))) b))>
#<alt (* -1 (/ (- (* -1 (+ x y)) (* -1 (* z (log t)))) b))>
#<alt (- (/ y b) (/ (* z (log t)) b))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))>
#<alt (/ x b)>
#<alt (* x (- (+ (/ 1 b) (/ y (* b x))) (/ (* z (log t)) (* b x))))>
#<alt (* x (- (+ (/ 1 b) (/ y (* b x))) (/ (* z (log t)) (* b x))))>
#<alt (* x (- (+ (/ 1 b) (/ y (* b x))) (/ (* z (log t)) (* b x))))>
#<alt (/ x b)>
#<alt (* -1 (* x (- (* -1 (/ (- (/ y b) (/ (* z (log t)) b)) x)) (/ 1 b))))>
#<alt (* -1 (* x (- (* -1 (/ (- (/ y b) (/ (* z (log t)) b)) x)) (/ 1 b))))>
#<alt (* -1 (* x (- (* -1 (/ (- (/ y b) (/ (* z (log t)) b)) x)) (/ 1 b))))>
#<alt (- (/ x b) (/ (* z (log t)) b))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))>
#<alt (/ y b)>
#<alt (* y (- (+ (/ 1 b) (/ x (* b y))) (/ (* z (log t)) (* b y))))>
#<alt (* y (- (+ (/ 1 b) (/ x (* b y))) (/ (* z (log t)) (* b y))))>
#<alt (* y (- (+ (/ 1 b) (/ x (* b y))) (/ (* z (log t)) (* b y))))>
#<alt (/ y b)>
#<alt (* -1 (* y (- (* -1 (/ (- (/ x b) (/ (* z (log t)) b)) y)) (/ 1 b))))>
#<alt (* -1 (* y (- (* -1 (/ (- (/ x b) (/ (* z (log t)) b)) y)) (/ 1 b))))>
#<alt (* -1 (* y (- (* -1 (/ (- (/ x b) (/ (* z (log t)) b)) y)) (/ 1 b))))>
#<alt (+ (/ x b) (/ y b))>
#<alt (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (/ y b)))>
#<alt (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (/ y b)))>
#<alt (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (/ y b)))>
#<alt (* -1 (/ (* z (log t)) b))>
#<alt (* z (- (+ (/ x (* b z)) (/ y (* b z))) (/ (log t) b)))>
#<alt (* z (- (+ (/ x (* b z)) (/ y (* b z))) (/ (log t) b)))>
#<alt (* z (- (+ (/ x (* b z)) (/ y (* b z))) (/ (log t) b)))>
#<alt (* -1 (/ (* z (log t)) b))>
#<alt (* -1 (* z (- (* -1 (/ (+ (/ x b) (/ y b)) z)) (* -1 (/ (log t) b)))))>
#<alt (* -1 (* z (- (* -1 (/ (+ (/ x b) (/ y b)) z)) (* -1 (/ (log t) b)))))>
#<alt (* -1 (* z (- (* -1 (/ (+ (/ x b) (/ y b)) z)) (* -1 (/ (log t) b)))))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))>
#<alt (- (+ (/ x b) (/ y b)) (* -1 (/ (* z (log (/ 1 t))) b)))>
#<alt (- (+ (/ x b) (/ y b)) (* -1 (/ (* z (log (/ 1 t))) b)))>
#<alt (- (+ (/ x b) (/ y b)) (* -1 (/ (* z (log (/ 1 t))) b)))>
#<alt (- (+ (/ x b) (/ y b)) (* -1 (/ (* z (log (/ 1 t))) b)))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))>
#<alt (- (+ (/ x b) (/ y b)) (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (/ b (log t))>
#<alt (* -1 (/ b (log (/ 1 t))))>
#<alt (* -1 (/ b (log (/ 1 t))))>
#<alt (* -1 (/ b (log (/ 1 t))))>
#<alt (* -1 (/ b (log (/ 1 t))))>
#<alt (/ b (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (/ b (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (/ b (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (/ b (+ (log -1) (* -1 (log (/ -1 t)))))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))>
#<alt (* -1 (* b (- (* 1/4 (/ 1 (pow a 2))) 1)))>
#<alt (* -1 (* b (- (* 1/4 (/ 1 (pow a 2))) 1)))>
#<alt (* -1 (* b (- (* 1/4 (/ 1 (pow a 2))) 1)))>
#<alt (* -1 (* b (- (* 1/4 (/ 1 (pow a 2))) 1)))>
#<alt (* -1/4 (/ b (pow a 2)))>
#<alt (/ (+ (* -1/4 b) (* (pow a 2) b)) (pow a 2))>
#<alt (/ (+ (* -1/4 b) (* (pow a 2) b)) (pow a 2))>
#<alt (/ (+ (* -1/4 b) (* (pow a 2) b)) (pow a 2))>
#<alt b>
#<alt (+ b (* -1/4 (/ b (pow a 2))))>
#<alt (+ b (* -1/4 (/ b (pow a 2))))>
#<alt (+ b (* -1/4 (/ b (pow a 2))))>
#<alt b>
#<alt (+ b (* -1/4 (/ b (pow a 2))))>
#<alt (+ b (* -1/4 (/ b (pow a 2))))>
#<alt (+ b (* -1/4 (/ b (pow a 2))))>
Calls

132 calls:

TimeVariablePointExpression
4.0ms
b
@0
(- (* (/ 1 b) (+ x y)) (/ z (/ b (log t))))
4.0ms
b
@inf
(- (* (/ 1 b) (+ x y)) (/ z (/ b (log t))))
3.0ms
b
@0
(* (* a a) (+ b (/ (* b -1/4) (* a a))))
3.0ms
a
@inf
(+ x (/ (* (* a a) (+ b (/ (* b -1/4) (* a a)))) (+ a 1/2)))
1.0ms
b
@inf
(* (* a a) (+ b (/ (* b -1/4) (* a a))))

rewrite554.0ms (4.3%)

Memory
48.6MiB live, 1 012.9MiB allocated
Algorithm
1×batch-egg-rewrite
Rules
5 604×accelerator-lowering-fma.f32
5 604×accelerator-lowering-fma.f64
5 184×/-lowering-/.f32
5 184×/-lowering-/.f64
4 848×*-lowering-*.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
034166
1243158
22531146
09964141
Stop Event
1×iter limit
1×node limit
Counts
17 → 625
Calls
Call 1
Inputs
(* (+ (+ a (+ -1/2 (/ z b))) (- (* (/ 1 b) (+ x y)) (/ z (/ b (log t))))) b)
(+ (+ a (+ -1/2 (/ z b))) (- (* (/ 1 b) (+ x y)) (/ z (/ b (log t)))))
(* (/ 1 b) (+ x y))
(+ a (+ -1/2 (/ z b)))
(* -1/2 b)
(+ (* -1/2 b) x)
(* (* a a) (+ b (/ (* b -1/4) (* a a))))
(+ x (/ (* (* a a) (+ b (/ (* b -1/4) (* a a)))) (+ a 1/2)))
(/ (* (* a a) (+ b (/ (* b -1/4) (* a a)))) (+ a 1/2))
(* a a)
(* (- 1 (log t)) z)
(- 1 (log t))
(log t)
(- (* (/ 1 b) (+ x y)) (/ z (/ b (log t))))
(/ b (log t))
(/ (* b -1/4) (* a a))
(+ b (/ (* b -1/4) (* a a)))
Outputs
(+.f64 (*.f64 b a) (*.f64 b (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))))
(+.f64 (*.f64 b (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 b (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))
(+.f64 (*.f64 b (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) (*.f64 b (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))
(+.f64 (*.f64 a b) (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) b))
(+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) b) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) b))
(+.f64 (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) b) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) b))
(fma.f64 a b (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) b))
(fma.f64 b a (*.f64 b (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))))
(fma.f64 b (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 b (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))
(fma.f64 b (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (*.f64 b (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))
(fma.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) b (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) b))
(fma.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) b (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) b))
(/.f64 (*.f64 b (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 3 binary64)))) (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))))
(/.f64 (*.f64 b (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64)))) (-.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))
(/.f64 (*.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 3 binary64))) b) (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))))
(/.f64 (*.f64 (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64))) b) (-.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))
(/.f64 (neg.f64 (*.f64 b (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 3 binary64))))) (neg.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))))))
(/.f64 (neg.f64 (*.f64 b (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64))))) (neg.f64 (-.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 3 binary64))) b)) (neg.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))))))
(/.f64 (neg.f64 (*.f64 (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64))) b)) (neg.f64 (-.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))))
(/.f64 (+.f64 (pow.f64 (*.f64 b a) #s(literal 3 binary64)) (pow.f64 (*.f64 b (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))) #s(literal 3 binary64))) (+.f64 (*.f64 (*.f64 b a) (*.f64 b a)) (-.f64 (*.f64 (*.f64 b (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))) (*.f64 b (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))) (*.f64 (*.f64 b a) (*.f64 b (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))))))
(/.f64 (+.f64 (pow.f64 (*.f64 b (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) #s(literal 3 binary64)) (pow.f64 (*.f64 b (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) #s(literal 3 binary64))) (+.f64 (*.f64 (*.f64 b (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 b (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (-.f64 (*.f64 (*.f64 b (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) (*.f64 b (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))) (*.f64 (*.f64 b (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 b (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))))))
(/.f64 (+.f64 (pow.f64 (*.f64 b (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) #s(literal 3 binary64)) (pow.f64 (*.f64 b (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) #s(literal 3 binary64))) (+.f64 (*.f64 (*.f64 b (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) (*.f64 b (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))) (-.f64 (*.f64 (*.f64 b (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 b (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (*.f64 (*.f64 b (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) (*.f64 b (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))))))
(/.f64 (+.f64 (pow.f64 (*.f64 a b) #s(literal 3 binary64)) (pow.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) b) #s(literal 3 binary64))) (+.f64 (*.f64 (*.f64 a b) (*.f64 a b)) (-.f64 (*.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) b) (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) b)) (*.f64 (*.f64 a b) (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) b)))))
(/.f64 (+.f64 (pow.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) b) #s(literal 3 binary64))) (+.f64 (*.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) b) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) b)) (-.f64 (*.f64 (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) b) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) b)) (*.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) b) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) b)))))
(/.f64 (+.f64 (pow.f64 (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) b) #s(literal 3 binary64))) (+.f64 (*.f64 (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) b) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) b)) (-.f64 (*.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) b) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) b)) (*.f64 (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) b) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) b)))))
(*.f64 b (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))
(*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) b)
(+.f64 a (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))
(+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 a (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))
(+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))
(+.f64 (/.f64 (+.f64 x y) b) (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))
(+.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))
(+.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 (/.f64 z b) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))
(+.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) a)
(+.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))
(+.f64 (+.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))
(+.f64 (+.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 a #s(literal -1/2 binary64))) (/.f64 z b))
(-.f64 (/.f64 (+.f64 x y) b) (-.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))
(-.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (/.f64 z (/.f64 b (log.f64 t))))
(-.f64 (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (-.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))) (/.f64 (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64)) (-.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))))
(-.f64 (/.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)))) (+.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b))) (+.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (/.f64 z (/.f64 b (log.f64 t))))))) (/.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)) (+.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b))) (+.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (/.f64 z (/.f64 b (log.f64 t))))))))
(-.f64 (/.f64 (*.f64 a a) (-.f64 a (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))) (/.f64 (pow.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) #s(literal 2 binary64)) (-.f64 a (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))))
(-.f64 (/.f64 (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64)) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))))
(-.f64 (/.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b))) (+.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (/.f64 z (/.f64 b (log.f64 t))))) (/.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (+.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (/.f64 z (/.f64 b (log.f64 t))))))
(fma.f64 #s(literal 1 binary64) (/.f64 (+.f64 x y) b) (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y) (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (+.f64 x y) #s(literal 1 binary64)) (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))
(fma.f64 (/.f64 (+.f64 x y) b) #s(literal 1 binary64) (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))
(fma.f64 (+.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 b (*.f64 b b)))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 (/.f64 z b) #s(literal -1/2 binary64)) (/.f64 b z)))) (+.f64 a (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))
(fma.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a)))) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))
(fma.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))
(fma.f64 (-.f64 #s(literal 1/4 binary64) (/.f64 (/.f64 z b) (/.f64 b z))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal -1/2 binary64) (/.f64 z b))) (+.f64 a (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))
(fma.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (/.f64 #s(literal 1 binary64) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))
(fma.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))
(fma.f64 (+.f64 x y) (/.f64 #s(literal 1 binary64) b) (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))
(fma.f64 (/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) b) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) #s(literal 1 binary64)) (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))
(fma.f64 (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) b) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 x y)) #s(literal 1 binary64)) (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))
(fma.f64 (/.f64 (+.f64 x y) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) b) (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))) (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))) (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64))))))
(/.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))))
(/.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 3 binary64))) (+.f64 (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))))
(/.f64 (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64))) (-.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))) (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))))
(/.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))) (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))) (*.f64 (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)) (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))))) (*.f64 (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))) (*.f64 (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)) (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))))) (*.f64 (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))
(/.f64 (+.f64 (*.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a)))) (*.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))) (*.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))) (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (*.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))))) (*.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))))
(/.f64 (+.f64 (*.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a)))) (*.f64 (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))) (*.f64 (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))) (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a)))))
(/.f64 (+.f64 (*.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (*.f64 (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))))) (*.f64 (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) #s(literal 2 binary64)) (*.f64 a (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))))))
(/.f64 (-.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b))) (+.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (/.f64 z (/.f64 b (log.f64 t)))))))
(/.f64 (-.f64 (*.f64 a a) (pow.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) #s(literal 2 binary64))) (-.f64 a (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))))
(/.f64 (-.f64 (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))
(/.f64 (-.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) (+.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (/.f64 z (/.f64 b (log.f64 t)))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))) (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)))))) (neg.f64 (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))) (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))) (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)))))) (neg.f64 (*.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))) (*.f64 (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)) (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)))))) (neg.f64 (*.f64 (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))) (*.f64 (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)) (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)))))) (neg.f64 (*.f64 (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a)))) (*.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))))) (neg.f64 (*.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))) (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (*.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)))))) (neg.f64 (*.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)))))
(/.f64 (neg.f64 (+.f64 (*.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a)))) (*.f64 (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))))) (neg.f64 (*.f64 (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))) (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))))))
(/.f64 (neg.f64 (+.f64 (*.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (*.f64 (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)))))) (neg.f64 (*.f64 (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)))))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (-.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))))
(/.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (pow.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 a a) (-.f64 (pow.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) #s(literal 2 binary64)) (*.f64 a (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b))) (+.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (/.f64 z (/.f64 b (log.f64 t))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 a a) (pow.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) #s(literal 2 binary64)))) (neg.f64 (-.f64 a (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))) (neg.f64 (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)))) (neg.f64 (+.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (/.f64 z (/.f64 b (log.f64 t))))))
(/.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))) (pow.f64 (+.f64 a (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (*.f64 (+.f64 a (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) (+.f64 a (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 a (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))))))
(/.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) #s(literal 3 binary64))) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (-.f64 (*.f64 (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (*.f64 (/.f64 (+.f64 x y) b) (+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))))))
(/.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (pow.f64 (+.f64 (/.f64 z b) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 (+.f64 (/.f64 z b) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) (+.f64 (/.f64 z b) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 (/.f64 z b) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))))))
(/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) #s(literal 3 binary64)) (*.f64 a (*.f64 a a))) (+.f64 (pow.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) #s(literal 2 binary64)) (-.f64 (*.f64 a a) (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) a))))
(/.f64 (+.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)))) (pow.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) #s(literal 3 binary64))) (+.f64 (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b))) (-.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (*.f64 (+.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (+.f64 x y) b)) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))))))
(/.f64 (+.f64 (pow.f64 (+.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) a) #s(literal 3 binary64)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (+.f64 (*.f64 (+.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) a) (+.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) a)) (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 (+.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) a) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))
(/.f64 (+.f64 (pow.f64 (+.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 a #s(literal -1/2 binary64))) #s(literal 3 binary64)) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 b (*.f64 b b)))) (+.f64 (*.f64 (+.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 a #s(literal -1/2 binary64))) (+.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (/.f64 (/.f64 z b) (/.f64 b z)) (*.f64 (+.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 a #s(literal -1/2 binary64))) (/.f64 z b)))))
(pow.f64 (/.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))))) (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)) (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (*.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (-.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))))))
(*.f64 (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))) (pow.f64 (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b))))
(+.f64 (/.f64 x b) (/.f64 y b))
(+.f64 (/.f64 y b) (/.f64 x b))
(-.f64 (/.f64 (/.f64 (*.f64 x x) (-.f64 x y)) b) (/.f64 (/.f64 (*.f64 y y) (-.f64 x y)) b))
(-.f64 (/.f64 (*.f64 (/.f64 x b) (/.f64 x b)) (/.f64 (-.f64 x y) b)) (/.f64 (*.f64 (/.f64 y b) (/.f64 y b)) (/.f64 (-.f64 x y) b)))
(fma.f64 #s(literal 1 binary64) (/.f64 x b) (/.f64 y b))
(fma.f64 #s(literal 1 binary64) (/.f64 y b) (/.f64 x b))
(fma.f64 (/.f64 #s(literal 1 binary64) b) x (/.f64 y b))
(fma.f64 (/.f64 #s(literal 1 binary64) b) y (/.f64 x b))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 x #s(literal 1 binary64)) (/.f64 y b))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 y #s(literal 1 binary64)) (/.f64 x b))
(fma.f64 x (/.f64 #s(literal 1 binary64) b) (/.f64 y b))
(fma.f64 y (/.f64 #s(literal 1 binary64) b) (/.f64 x b))
(fma.f64 (/.f64 x b) #s(literal 1 binary64) (/.f64 y b))
(fma.f64 (/.f64 y b) #s(literal 1 binary64) (/.f64 x b))
(fma.f64 (*.f64 x #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) b) (/.f64 y b))
(fma.f64 (*.f64 y #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) b) (/.f64 x b))
(fma.f64 (/.f64 x #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) b) (/.f64 y b))
(fma.f64 (/.f64 y #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) b) (/.f64 x b))
(/.f64 #s(literal 1 binary64) (/.f64 b (+.f64 x y)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 b (+.f64 x y))))
(/.f64 (+.f64 x y) b)
(/.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (*.f64 b (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))))
(/.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 x x) (*.f64 y y))) (*.f64 b (-.f64 x y)))
(/.f64 (*.f64 #s(literal -1 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (*.f64 (-.f64 #s(literal 0 binary64) b) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))))
(/.f64 (*.f64 #s(literal -1 binary64) (-.f64 (*.f64 x x) (*.f64 y y))) (*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 x y)))
(/.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) #s(literal 1 binary64)) (*.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) b))
(/.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) #s(literal -1 binary64)) (*.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (-.f64 #s(literal 0 binary64) b)))
(/.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 y y)) #s(literal 1 binary64)) (*.f64 (-.f64 x y) b))
(/.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 y y)) #s(literal -1 binary64)) (*.f64 (-.f64 x y) (-.f64 #s(literal 0 binary64) b)))
(/.f64 (neg.f64 (+.f64 x y)) (-.f64 #s(literal 0 binary64) b))
(/.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b)))) (+.f64 (*.f64 (/.f64 x b) (/.f64 x b)) (-.f64 (*.f64 (/.f64 y b) (/.f64 y b)) (*.f64 (/.f64 x b) (/.f64 y b)))))
(/.f64 (-.f64 (*.f64 (/.f64 x b) (/.f64 x b)) (*.f64 (/.f64 y b) (/.f64 y b))) (/.f64 (-.f64 x y) b))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y)))) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (*.f64 x x) (*.f64 y y))) (-.f64 x y))
(/.f64 (*.f64 (+.f64 x y) #s(literal -1 binary64)) (-.f64 #s(literal 0 binary64) b))
(/.f64 (*.f64 #s(literal -1 binary64) (+.f64 x y)) (-.f64 #s(literal 0 binary64) b))
(/.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) b)) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))
(/.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (/.f64 #s(literal 1 binary64) b)) (-.f64 x y))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (neg.f64 (*.f64 b (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) (-.f64 (*.f64 x x) (*.f64 y y)))) (neg.f64 (*.f64 b (-.f64 x y))))
(/.f64 (neg.f64 (*.f64 #s(literal -1 binary64) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (neg.f64 (*.f64 (-.f64 #s(literal 0 binary64) b) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))))))
(/.f64 (neg.f64 (*.f64 #s(literal -1 binary64) (-.f64 (*.f64 x x) (*.f64 y y)))) (neg.f64 (*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 x y))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) #s(literal 1 binary64))) (neg.f64 (*.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) b)))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) #s(literal -1 binary64))) (neg.f64 (*.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x))) (-.f64 #s(literal 0 binary64) b))))
(/.f64 (neg.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 y y)) #s(literal 1 binary64))) (neg.f64 (*.f64 (-.f64 x y) b)))
(/.f64 (neg.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 y y)) #s(literal -1 binary64))) (neg.f64 (*.f64 (-.f64 x y) (-.f64 #s(literal 0 binary64) b))))
(/.f64 (neg.f64 (neg.f64 (+.f64 x y))) (neg.f64 (-.f64 #s(literal 0 binary64) b)))
(/.f64 (neg.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b))))) (neg.f64 (+.f64 (*.f64 (/.f64 x b) (/.f64 x b)) (-.f64 (*.f64 (/.f64 y b) (/.f64 y b)) (*.f64 (/.f64 x b) (/.f64 y b))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (/.f64 x b) (/.f64 x b)) (*.f64 (/.f64 y b) (/.f64 y b)))) (neg.f64 (/.f64 (-.f64 x y) b)))
(/.f64 (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))))) (neg.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))))
(/.f64 (neg.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (*.f64 x x) (*.f64 y y)))) (neg.f64 (-.f64 x y)))
(/.f64 (neg.f64 (*.f64 (+.f64 x y) #s(literal -1 binary64))) (neg.f64 (-.f64 #s(literal 0 binary64) b)))
(/.f64 (neg.f64 (*.f64 #s(literal -1 binary64) (+.f64 x y))) (neg.f64 (-.f64 #s(literal 0 binary64) b)))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) b))) (neg.f64 (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))))
(/.f64 (neg.f64 (*.f64 (-.f64 (*.f64 x x) (*.f64 y y)) (/.f64 #s(literal 1 binary64) b))) (neg.f64 (-.f64 x y)))
(/.f64 (+.f64 (/.f64 (*.f64 y (*.f64 y y)) (*.f64 b (*.f64 b b))) (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b)))) (+.f64 (*.f64 (/.f64 y b) (/.f64 y b)) (-.f64 (*.f64 (/.f64 x b) (/.f64 x b)) (*.f64 (/.f64 y b) (/.f64 x b)))))
(pow.f64 (/.f64 b (+.f64 x y)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (+.f64 x y) b))
(*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y))
(*.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (+.f64 x y) #s(literal 1 binary64)))
(*.f64 (/.f64 (+.f64 x y) b) #s(literal 1 binary64))
(*.f64 (+.f64 x y) (/.f64 #s(literal 1 binary64) b))
(*.f64 (/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) b) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) #s(literal 1 binary64)))
(*.f64 (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) b) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 x y)) #s(literal 1 binary64)))
(*.f64 (/.f64 (+.f64 x y) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) b))
(+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))
(+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a))
(+.f64 (/.f64 z b) (+.f64 a #s(literal -1/2 binary64)))
(+.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a)
(+.f64 (+.f64 a #s(literal -1/2 binary64)) (/.f64 z b))
(+.f64 (+.f64 a (/.f64 z b)) #s(literal -1/2 binary64))
(-.f64 (/.f64 (*.f64 a a) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))))
(-.f64 (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a)) (/.f64 (*.f64 a a) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a)))
(-.f64 (/.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (-.f64 (+.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (/.f64 (/.f64 (/.f64 z b) (/.f64 b z)) (-.f64 (+.f64 a #s(literal -1/2 binary64)) (/.f64 z b))))
(fma.f64 z (/.f64 #s(literal 1 binary64) b) (+.f64 a #s(literal -1/2 binary64)))
(fma.f64 (/.f64 z b) #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64)))
(fma.f64 #s(literal 1 binary64) (/.f64 z b) (+.f64 a #s(literal -1/2 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) b) z (+.f64 a #s(literal -1/2 binary64)))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (pow.f64 (/.f64 #s(literal 1 binary64) z) #s(literal -1 binary64)) (+.f64 a #s(literal -1/2 binary64)))
(fma.f64 (-.f64 #s(literal 0 binary64) z) (/.f64 #s(literal -1 binary64) b) (+.f64 a #s(literal -1/2 binary64)))
(fma.f64 (+.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 b (*.f64 b b)))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 (/.f64 z b) #s(literal -1/2 binary64)) (/.f64 b z)))) a)
(fma.f64 (-.f64 #s(literal 1/4 binary64) (/.f64 (/.f64 z b) (/.f64 b z))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal -1/2 binary64) (/.f64 z b))) a)
(fma.f64 (*.f64 z #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) b) (+.f64 a #s(literal -1/2 binary64)))
(fma.f64 (/.f64 z #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) b) (+.f64 a #s(literal -1/2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))))
(/.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (*.f64 a a) (*.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))
(/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)))
(/.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a)))))
(/.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) (neg.f64 (+.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (*.f64 a a) (*.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))))
(/.f64 (neg.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)))) (neg.f64 (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))))
(/.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 b (*.f64 b b)))) (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (-.f64 (/.f64 (/.f64 z b) (/.f64 b z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (/.f64 z b)))))
(/.f64 (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 a a)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))
(/.f64 (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (/.f64 (/.f64 z b) (/.f64 b z))) (-.f64 (+.f64 a #s(literal -1/2 binary64)) (/.f64 z b)))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))))) (neg.f64 (neg.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))))) (neg.f64 (neg.f64 (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)))))
(/.f64 (neg.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (*.f64 z (*.f64 z z)) (*.f64 b (*.f64 b b))))) (neg.f64 (+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (-.f64 (/.f64 (/.f64 z b) (/.f64 b z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (/.f64 z b))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (*.f64 a a))) (neg.f64 (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a)))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (/.f64 (/.f64 z b) (/.f64 b z)))) (neg.f64 (-.f64 (+.f64 a #s(literal -1/2 binary64)) (/.f64 z b))))
(/.f64 (+.f64 #s(literal -1/8 binary64) (pow.f64 (+.f64 (/.f64 z b) a) #s(literal 3 binary64))) (+.f64 #s(literal 1/4 binary64) (-.f64 (*.f64 (+.f64 (/.f64 z b) a) (+.f64 (/.f64 z b) a)) (*.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)))))
(/.f64 (+.f64 (/.f64 (*.f64 z (*.f64 z z)) (*.f64 b (*.f64 b b))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))))) (+.f64 (/.f64 (/.f64 z b) (/.f64 b z)) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (*.f64 (/.f64 z b) (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (pow.f64 (+.f64 a (/.f64 z b)) #s(literal 3 binary64)) #s(literal -1/8 binary64)) (+.f64 (*.f64 (+.f64 a (/.f64 z b)) (+.f64 a (/.f64 z b))) (-.f64 #s(literal 1/4 binary64) (*.f64 (+.f64 a (/.f64 z b)) #s(literal -1/2 binary64)))))
(pow.f64 (/.f64 (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a))) (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b)))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b)))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 a (*.f64 a a)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (+.f64 #s(literal -1/2 binary64) (/.f64 z b))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (*.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) (-.f64 (+.f64 #s(literal -1/2 binary64) (/.f64 z b)) a)))))
(*.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 z b) a)) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))) (/.f64 #s(literal 1 binary64) (-.f64 (-.f64 a #s(literal -1/2 binary64)) (/.f64 z b))))
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b #s(literal -1/2 binary64))
(+.f64 x (*.f64 #s(literal -1/2 binary64) b))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
(-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (-.f64 (*.f64 #s(literal -1/2 binary64) b) x)) (/.f64 (*.f64 x x) (-.f64 (*.f64 #s(literal -1/2 binary64) b) x)))
(-.f64 (/.f64 (*.f64 x x) (-.f64 x (*.f64 #s(literal -1/2 binary64) b))) (/.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (-.f64 x (*.f64 #s(literal -1/2 binary64) b))))
(fma.f64 #s(literal -1/2 binary64) b x)
(fma.f64 b #s(literal -1/2 binary64) x)
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 #s(literal -1/2 binary64) b) x) (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (*.f64 #s(literal -1/2 binary64) b) x) (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x)))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (*.f64 x x) (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x (*.f64 #s(literal -1/2 binary64) b)))))
(/.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x)) (-.f64 (*.f64 #s(literal -1/2 binary64) b) x))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))) (neg.f64 (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x (-.f64 x (*.f64 #s(literal -1/2 binary64) b))))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))) (neg.f64 (+.f64 (*.f64 x x) (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x (*.f64 #s(literal -1/2 binary64) b))))))
(/.f64 (neg.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x))) (neg.f64 (-.f64 (*.f64 #s(literal -1/2 binary64) b) x)))
(/.f64 (-.f64 (*.f64 x x) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))) (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))) (neg.f64 (neg.f64 (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x)))) (neg.f64 (neg.f64 (-.f64 (*.f64 #s(literal -1/2 binary64) b) x))))
(/.f64 (neg.f64 (-.f64 (*.f64 x x) (*.f64 #s(literal 1/4 binary64) (*.f64 b b)))) (neg.f64 (-.f64 x (*.f64 #s(literal -1/2 binary64) b))))
(pow.f64 (/.f64 (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (*.f64 #s(literal -1/2 binary64) b) x) (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x (-.f64 x (*.f64 #s(literal -1/2 binary64) b))))))
(*.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal -1/2 binary64) b) x)))
(+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))
(+.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)) (*.f64 a (*.f64 a b)))
(-.f64 (/.f64 (*.f64 (*.f64 a (*.f64 a b)) (*.f64 a (*.f64 a b))) (-.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))) (/.f64 (*.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (-.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))
(fma.f64 a (*.f64 a b) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))
(fma.f64 a (*.f64 a (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a (*.f64 a b)))
(fma.f64 b (*.f64 a a) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))
(fma.f64 b (*.f64 (/.f64 #s(literal -1/4 binary64) (*.f64 a a)) (*.f64 a a)) (*.f64 a (*.f64 a b)))
(fma.f64 (*.f64 a a) b (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))
(fma.f64 (*.f64 a a) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) (*.f64 a (*.f64 a b)))
(fma.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) (*.f64 a a) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 b a) (*.f64 (/.f64 #s(literal -1/4 binary64) a) (*.f64 a a)) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 b a) (/.f64 (*.f64 a a) (/.f64 a #s(literal -1/4 binary64))) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 #s(literal -1/4 binary64) a) (/.f64 (*.f64 a a) (/.f64 a b)) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 #s(literal 1 binary64) (*.f64 a a)) (/.f64 (*.f64 a a) (/.f64 #s(literal 1 binary64) (*.f64 b #s(literal -1/4 binary64)))) (*.f64 a (*.f64 a b)))
(fma.f64 (*.f64 a (*.f64 a b)) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)) (*.f64 a (*.f64 a b)))
(fma.f64 (*.f64 b (/.f64 #s(literal -1/4 binary64) a)) (/.f64 (*.f64 a a) a) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 (*.f64 a a) (/.f64 a (*.f64 b #s(literal -1/4 binary64)))) (*.f64 a (*.f64 a b)))
(fma.f64 (*.f64 b a) a (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))
(fma.f64 (*.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) a) a (*.f64 a (*.f64 a b)))
(fma.f64 (*.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) (*.f64 a a)) (*.f64 a (*.f64 a b)))
(fma.f64 (*.f64 (*.f64 a a) (/.f64 b a)) (/.f64 #s(literal -1/4 binary64) a) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 a a) (/.f64 a (/.f64 a (*.f64 b #s(literal -1/4 binary64)))) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 a (*.f64 a a)) (/.f64 a (/.f64 #s(literal 1 binary64) (*.f64 b #s(literal -1/4 binary64)))) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 a (/.f64 a b)) (/.f64 a (/.f64 a #s(literal -1/4 binary64))) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 a (/.f64 a #s(literal -1/4 binary64))) (/.f64 a (/.f64 a b)) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 (*.f64 a a) a) (*.f64 b (/.f64 #s(literal -1/4 binary64) a)) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 (*.f64 a a) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b #s(literal -1/4 binary64)))) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 (*.f64 a a) (/.f64 a b)) (/.f64 #s(literal -1/4 binary64) a) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 (*.f64 a a) (/.f64 a #s(literal -1/4 binary64))) (/.f64 b a) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 (*.f64 a a) #s(literal -1 binary64)) (/.f64 (*.f64 b #s(literal 1/4 binary64)) (*.f64 a a)) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 (*.f64 a a) (neg.f64 a)) (/.f64 (*.f64 b #s(literal 1/4 binary64)) a) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 (*.f64 b #s(literal 1/4 binary64)) a) (/.f64 (*.f64 a a) (neg.f64 a)) (*.f64 a (*.f64 a b)))
(fma.f64 (/.f64 (*.f64 b #s(literal 1/4 binary64)) #s(literal -1 binary64)) (/.f64 (*.f64 a a) (*.f64 a a)) (*.f64 a (*.f64 a b)))
(/.f64 (+.f64 (*.f64 (*.f64 b (*.f64 b b)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a)))) (*.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) #s(literal 1 binary64))) (+.f64 (*.f64 (*.f64 a (*.f64 a b)) (*.f64 a (*.f64 a b))) (-.f64 (*.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (*.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))
(/.f64 (-.f64 (*.f64 (*.f64 a (*.f64 a b)) (*.f64 a (*.f64 a b))) (*.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))) (-.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))
(/.f64 (*.f64 (*.f64 a a) (+.f64 (*.f64 b (*.f64 b b)) (/.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a)))))) (+.f64 (*.f64 b b) (/.f64 (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b) (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))))))
(/.f64 (*.f64 (*.f64 a a) (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a)))) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))
(/.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) (/.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a))))) (*.f64 a a)) (+.f64 (*.f64 b b) (/.f64 (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b) (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))))))
(/.f64 (*.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))) (*.f64 a a)) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))
(/.f64 (neg.f64 (+.f64 (*.f64 (*.f64 b (*.f64 b b)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a)))) (*.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) #s(literal 1 binary64)))) (neg.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a b)) (*.f64 a (*.f64 a b))) (-.f64 (*.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (*.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (*.f64 a (*.f64 a b)) (*.f64 a (*.f64 a b))) (*.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))) (neg.f64 (-.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))
(/.f64 (neg.f64 (*.f64 (*.f64 a a) (+.f64 (*.f64 b (*.f64 b b)) (/.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a))))))) (neg.f64 (+.f64 (*.f64 b b) (/.f64 (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b) (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64)))))))
(/.f64 (neg.f64 (*.f64 (*.f64 a a) (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))))) (neg.f64 (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 b (*.f64 b b)) (/.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a))))) (*.f64 a a))) (neg.f64 (+.f64 (*.f64 b b) (/.f64 (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b) (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64)))))))
(/.f64 (neg.f64 (*.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))) (*.f64 a a))) (neg.f64 (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))))
(/.f64 (+.f64 (*.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) #s(literal 1 binary64)) (*.f64 (*.f64 b (*.f64 b b)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a))))) (+.f64 (*.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (-.f64 (*.f64 (*.f64 a (*.f64 a b)) (*.f64 a (*.f64 a b))) (*.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)) (*.f64 a (*.f64 a b))))))
(*.f64 a (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))))
(*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))
(*.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))
(*.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) a)
(+.f64 x (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) x)
(-.f64 (/.f64 (*.f64 x x) (-.f64 x (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))))) (/.f64 (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))) (-.f64 x (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))))))
(-.f64 (/.f64 (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))) (-.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) x)) (/.f64 (*.f64 x x) (-.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) x)))
(fma.f64 a (*.f64 a (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (+.f64 a #s(literal 1/2 binary64)))) x)
(fma.f64 a (*.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))) x)
(fma.f64 a (/.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))) x)
(fma.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) x)
(fma.f64 (*.f64 a a) (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (+.f64 a #s(literal 1/2 binary64))) x)
(fma.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 (*.f64 a a) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))) x)
(fma.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (/.f64 (*.f64 a a) (+.f64 a #s(literal 1/2 binary64))) x)
(fma.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) x)
(fma.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal -1/2 binary64) (neg.f64 a))) x)
(fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) x)
(fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))) #s(literal -1 binary64)) x)
(fma.f64 (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 a a) x)
(fma.f64 (/.f64 (*.f64 a a) #s(literal 1 binary64)) (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (+.f64 a #s(literal 1/2 binary64))) x)
(fma.f64 (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (/.f64 (*.f64 a a) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))) x)
(fma.f64 (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 (*.f64 a a) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64)))) x)
(fma.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))) x)
(fma.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))) x)
(fma.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 a #s(literal -1/2 binary64)) x)
(fma.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64)))) x)
(fma.f64 (/.f64 a (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64)))) x)
(fma.f64 (/.f64 a #s(literal -1 binary64)) (/.f64 (neg.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))) (+.f64 a #s(literal 1/2 binary64))) x)
(fma.f64 (/.f64 (neg.f64 a) #s(literal -1 binary64)) (/.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))) x)
(fma.f64 (/.f64 (*.f64 a a) #s(literal -1 binary64)) (/.f64 (neg.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))) x)
(fma.f64 (/.f64 a (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (/.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))) x)
(fma.f64 (/.f64 (*.f64 a a) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))) x)
(fma.f64 (/.f64 (*.f64 a a) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64)))) x)
(fma.f64 (/.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (/.f64 a (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))) x)
(fma.f64 (/.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 a (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64)))) x)
(fma.f64 (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 a a)) (+.f64 a #s(literal 1/2 binary64))) x)
(fma.f64 (/.f64 (neg.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) #s(literal -1 binary64)) (/.f64 (*.f64 a a) (+.f64 a #s(literal 1/2 binary64))) x)
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 x x) (/.f64 (-.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) x) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 x (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64)))) (-.f64 (*.f64 x x) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 x x) (/.f64 (-.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) x) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 x (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64)))) (-.f64 (*.f64 x x) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))) (+.f64 (*.f64 x x) (/.f64 (-.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) x) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))) (+.f64 (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))) (-.f64 (*.f64 x x) (/.f64 x (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))))
(/.f64 (-.f64 (*.f64 x x) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))) (-.f64 x (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))))) (neg.f64 (+.f64 (*.f64 x x) (/.f64 (-.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) x) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))))
(/.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))))) (neg.f64 (+.f64 (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))) (-.f64 (*.f64 x x) (/.f64 x (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 x x) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))) (neg.f64 (-.f64 x (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))))))
(/.f64 (-.f64 (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))) (*.f64 x x)) (-.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) x))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))))) (neg.f64 (neg.f64 (+.f64 (*.f64 x x) (/.f64 (-.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) x) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 x x) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))))) (neg.f64 (neg.f64 (-.f64 x (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))) (*.f64 x x))) (neg.f64 (-.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) x)))
(pow.f64 (/.f64 (+.f64 (*.f64 x x) (/.f64 (-.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) x) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))) (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 x (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64)))) (-.f64 (*.f64 x x) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (/.f64 (-.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) x) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))))
(*.f64 (-.f64 (*.f64 x x) (/.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))) (/.f64 #s(literal 1 binary64) (-.f64 x (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))) #s(literal -1 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (+.f64 #s(literal -1/2 binary64) (neg.f64 a))) (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 #s(literal -1/2 binary64) (neg.f64 a))))
(neg.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 #s(literal -1/2 binary64) (neg.f64 a))))
(neg.f64 (/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))))
(/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))) #s(literal 1 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))) (+.f64 #s(literal -1/2 binary64) (neg.f64 a)))
(/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) #s(literal 1 binary64)) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))) (neg.f64 (+.f64 #s(literal -1/2 binary64) (neg.f64 a))))
(/.f64 (neg.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) #s(literal 1 binary64))) (+.f64 #s(literal -1/2 binary64) (neg.f64 a)))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))))) (neg.f64 (neg.f64 (+.f64 #s(literal -1/2 binary64) (neg.f64 a)))))
(pow.f64 (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 a (*.f64 a (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (+.f64 a #s(literal 1/2 binary64)))))
(*.f64 a (*.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))))
(*.f64 a (/.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 (*.f64 a a) (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 (*.f64 a a) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))))
(*.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (/.f64 (*.f64 a a) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 (-.f64 #s(literal 0 binary64) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal -1/2 binary64) (neg.f64 a))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)))) #s(literal -1 binary64)))
(*.f64 (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (+.f64 a #s(literal 1/2 binary64))) (*.f64 a a))
(*.f64 (/.f64 (*.f64 a a) #s(literal 1 binary64)) (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (/.f64 (*.f64 a a) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))))
(*.f64 (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 (*.f64 a a) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64)))))
(*.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))
(*.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))))
(*.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (+.f64 a #s(literal -1/2 binary64)))
(*.f64 (/.f64 (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64)))))
(*.f64 (/.f64 a (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64)))))
(*.f64 (/.f64 a #s(literal -1 binary64)) (/.f64 (neg.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 (/.f64 (neg.f64 a) #s(literal -1 binary64)) (/.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 (/.f64 (*.f64 a a) #s(literal -1 binary64)) (/.f64 (neg.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 (/.f64 a (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (/.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))))
(*.f64 (/.f64 (*.f64 a a) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))))
(*.f64 (/.f64 (*.f64 a a) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64)))))
(*.f64 (/.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 (*.f64 a (*.f64 a a)) #s(literal 1/8 binary64))) (/.f64 a (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal 1/2 binary64)))))))
(*.f64 (/.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 (*.f64 a a) #s(literal -1/4 binary64))) (/.f64 a (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64)))))
(*.f64 (/.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 0 binary64) (*.f64 a a)) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 (/.f64 (neg.f64 (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) #s(literal -1 binary64)) (/.f64 (*.f64 a a) (+.f64 a #s(literal 1/2 binary64))))
(exp.f64 (*.f64 (log.f64 a) #s(literal 2 binary64)))
(pow.f64 a #s(literal 2 binary64))
(pow.f64 (*.f64 a a) #s(literal 1 binary64))
(pow.f64 (exp.f64 (log.f64 a)) #s(literal 2 binary64))
(*.f64 a a)
(*.f64 (exp.f64 (log.f64 a)) (exp.f64 (log.f64 a)))
(+.f64 (*.f64 z #s(literal 1 binary64)) (*.f64 z (log.f64 (/.f64 #s(literal 1 binary64) t))))
(+.f64 (*.f64 #s(literal 1 binary64) z) (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) t)) z))
(fma.f64 z #s(literal 1 binary64) (*.f64 z (log.f64 (/.f64 #s(literal 1 binary64) t))))
(fma.f64 #s(literal 1 binary64) z (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) t)) z))
(/.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (+.f64 #s(literal 1 binary64) (log.f64 t)))
(/.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) z) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) z) (+.f64 #s(literal 1 binary64) (log.f64 t)))
(/.f64 (neg.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t))))))
(/.f64 (neg.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (neg.f64 (+.f64 #s(literal 1 binary64) (log.f64 t))))
(/.f64 (neg.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) z)) (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t))))))
(/.f64 (neg.f64 (*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) z)) (neg.f64 (+.f64 #s(literal 1 binary64) (log.f64 t))))
(/.f64 (+.f64 (pow.f64 (*.f64 z #s(literal 1 binary64)) #s(literal 3 binary64)) (pow.f64 (*.f64 z (log.f64 (/.f64 #s(literal 1 binary64) t))) #s(literal 3 binary64))) (+.f64 (*.f64 (*.f64 z #s(literal 1 binary64)) (*.f64 z #s(literal 1 binary64))) (-.f64 (*.f64 (*.f64 z (log.f64 (/.f64 #s(literal 1 binary64) t))) (*.f64 z (log.f64 (/.f64 #s(literal 1 binary64) t)))) (*.f64 (*.f64 z #s(literal 1 binary64)) (*.f64 z (log.f64 (/.f64 #s(literal 1 binary64) t)))))))
(/.f64 (+.f64 (pow.f64 (*.f64 #s(literal 1 binary64) z) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) t)) z) #s(literal 3 binary64))) (+.f64 (*.f64 (*.f64 #s(literal 1 binary64) z) (*.f64 #s(literal 1 binary64) z)) (-.f64 (*.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) t)) z) (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) t)) z)) (*.f64 (*.f64 #s(literal 1 binary64) z) (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) t)) z)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
(+.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) t)))
(+.f64 (log.f64 (/.f64 #s(literal 1 binary64) t)) #s(literal 1 binary64))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t))))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t))))))
(-.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (log.f64 t))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (+.f64 #s(literal 1 binary64) (log.f64 t))))
(-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) t)))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) t)))))
(fma.f64 #s(literal -1 binary64) (log.f64 t) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) t))))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (+.f64 #s(literal 1 binary64) (log.f64 t)))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (-.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) t))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t))))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (*.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) t)))))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (log.f64 t))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) (neg.f64 (-.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) t)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (+.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 (+.f64 (neg.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64))) #s(literal 1 binary64)) (+.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) t)) #s(literal 1 binary64)))))
(pow.f64 (/.f64 (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)))) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 #s(literal 1 binary64) (log.f64 t)) (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (*.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t))))))
(*.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (log.f64 t))))
(log.f64 t)
(*.f64 #s(literal 1 binary64) (log.f64 t))
(*.f64 (log.f64 t) #s(literal 1 binary64))
(+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))
(+.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (/.f64 (+.f64 x y) b))
(+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))))
(+.f64 (/.f64 x b) (/.f64 (-.f64 y (*.f64 z (log.f64 t))) b))
(-.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))
(-.f64 (/.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))) (/.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))))
(-.f64 (/.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))) (/.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))
(-.f64 (/.f64 (*.f64 (+.f64 x y) (/.f64 b (log.f64 t))) (*.f64 b (/.f64 b (log.f64 t)))) (/.f64 (*.f64 b z) (*.f64 b (/.f64 b (log.f64 t)))))
(-.f64 (/.f64 (*.f64 (+.f64 x y) (/.f64 b (*.f64 z (log.f64 t)))) (*.f64 b (/.f64 b (*.f64 z (log.f64 t))))) (/.f64 b (*.f64 b (/.f64 b (*.f64 z (log.f64 t))))))
(-.f64 (/.f64 (*.f64 (+.f64 x y) (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (*.f64 b (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))) (/.f64 (*.f64 b (-.f64 #s(literal 0 binary64) z)) (*.f64 b (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))))
(-.f64 (/.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (-.f64 (/.f64 (+.f64 x y) b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))) (/.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (-.f64 (/.f64 (+.f64 x y) b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))))
(fma.f64 z (neg.f64 (/.f64 (log.f64 t) b)) (/.f64 (+.f64 x y) b))
(fma.f64 (/.f64 z b) (log.f64 (/.f64 #s(literal 1 binary64) t)) (/.f64 (+.f64 x y) b))
(fma.f64 #s(literal 1 binary64) (/.f64 (+.f64 x y) b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))
(fma.f64 #s(literal 1 binary64) (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))))
(fma.f64 #s(literal 1 binary64) (/.f64 x b) (/.f64 (-.f64 y (*.f64 z (log.f64 t))) b))
(fma.f64 (/.f64 #s(literal 1 binary64) b) x (+.f64 (/.f64 y b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) x (/.f64 (-.f64 y (*.f64 z (log.f64 t))) b))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (+.f64 x y) #s(literal 1 binary64)) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 z (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) t)))) (/.f64 (+.f64 x y) b))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 x #s(literal 1 binary64)) (+.f64 (/.f64 y b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))))
(fma.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 x #s(literal 1 binary64)) (/.f64 (-.f64 y (*.f64 z (log.f64 t))) b))
(fma.f64 x (/.f64 #s(literal 1 binary64) b) (+.f64 (/.f64 y b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))))
(fma.f64 x (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 y (*.f64 z (log.f64 t))) b))
(fma.f64 (/.f64 (+.f64 x y) b) #s(literal 1 binary64) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))
(fma.f64 #s(literal -1 binary64) (/.f64 z (/.f64 b (log.f64 t))) (/.f64 (+.f64 x y) b))
(fma.f64 (-.f64 #s(literal 0 binary64) z) (/.f64 (log.f64 t) b) (/.f64 (+.f64 x y) b))
(fma.f64 (/.f64 x b) #s(literal 1 binary64) (+.f64 (/.f64 y b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))))
(fma.f64 (/.f64 x b) #s(literal 1 binary64) (/.f64 (-.f64 y (*.f64 z (log.f64 t))) b))
(fma.f64 (+.f64 x y) (/.f64 #s(literal 1 binary64) b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))
(fma.f64 (/.f64 #s(literal -1 binary64) b) (/.f64 z (/.f64 #s(literal 1 binary64) (log.f64 t))) (/.f64 (+.f64 x y) b))
(fma.f64 (neg.f64 (/.f64 z b)) (log.f64 t) (/.f64 (+.f64 x y) b))
(fma.f64 (*.f64 x #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) b) (+.f64 (/.f64 y b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))))
(fma.f64 (*.f64 x #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 y (*.f64 z (log.f64 t))) b))
(fma.f64 (/.f64 (+.f64 (*.f64 x (*.f64 x x)) (*.f64 y (*.f64 y y))) b) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 x x) (*.f64 y (-.f64 y x)))) #s(literal 1 binary64)) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))
(fma.f64 (/.f64 (-.f64 (*.f64 x x) (*.f64 y y)) b) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 x y)) #s(literal 1 binary64)) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))
(fma.f64 (/.f64 (+.f64 x y) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))
(fma.f64 (/.f64 x #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) b) (+.f64 (/.f64 y b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))))
(fma.f64 (/.f64 x #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) b) (/.f64 (-.f64 y (*.f64 z (log.f64 t))) b))
(fma.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 t))) (/.f64 z b) (/.f64 (+.f64 x y) b))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))) (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))) (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))) (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))) (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))))))
(/.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))))
(/.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (-.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (*.f64 (/.f64 (+.f64 x y) b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))))))
(/.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))
(/.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) (-.f64 (/.f64 (+.f64 x y) b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))))
(/.f64 (-.f64 (*.f64 (+.f64 x y) (/.f64 b (log.f64 t))) (*.f64 b z)) (*.f64 b (/.f64 b (log.f64 t))))
(/.f64 (-.f64 (*.f64 (+.f64 x y) (/.f64 b (*.f64 z (log.f64 t)))) b) (*.f64 b (/.f64 b (*.f64 z (log.f64 t)))))
(/.f64 (-.f64 (*.f64 (+.f64 x y) (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (*.f64 b (-.f64 #s(literal 0 binary64) z))) (*.f64 b (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (-.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (*.f64 (/.f64 (+.f64 x y) b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))))))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)))) (neg.f64 (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (/.f64 (+.f64 x y) b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))))
(/.f64 (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))) b)
(/.f64 (-.f64 (neg.f64 (+.f64 x y)) (*.f64 (-.f64 #s(literal 0 binary64) z) (log.f64 t))) (-.f64 #s(literal 0 binary64) b))
(/.f64 (-.f64 (*.f64 (+.f64 x y) #s(literal -1 binary64)) (*.f64 (-.f64 #s(literal 0 binary64) z) (log.f64 t))) (-.f64 #s(literal 0 binary64) b))
(/.f64 (-.f64 (*.f64 #s(literal -1 binary64) (+.f64 x y)) (*.f64 (-.f64 #s(literal 0 binary64) z) (log.f64 t))) (-.f64 #s(literal 0 binary64) b))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x y) (/.f64 b (log.f64 t))) (*.f64 b z))) (neg.f64 (*.f64 b (/.f64 b (log.f64 t)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x y) (/.f64 b (*.f64 z (log.f64 t)))) b)) (neg.f64 (*.f64 b (/.f64 b (*.f64 z (log.f64 t))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 x y) (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (*.f64 b (-.f64 #s(literal 0 binary64) z)))) (neg.f64 (*.f64 b (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))))
(/.f64 (+.f64 (pow.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) #s(literal 3 binary64)) (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b)))) (+.f64 (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)) (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))) (/.f64 (+.f64 x y) b)))))
(/.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (pow.f64 (+.f64 (/.f64 y b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))) #s(literal 3 binary64))) (+.f64 (*.f64 (/.f64 x b) (/.f64 x b)) (-.f64 (*.f64 (+.f64 (/.f64 y b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))) (+.f64 (/.f64 y b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))) (*.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t)))))))))
(/.f64 (+.f64 (/.f64 (*.f64 x (*.f64 x x)) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 (-.f64 y (*.f64 z (log.f64 t))) b) #s(literal 3 binary64))) (+.f64 (*.f64 (/.f64 x b) (/.f64 x b)) (-.f64 (*.f64 (/.f64 (-.f64 y (*.f64 z (log.f64 t))) b) (/.f64 (-.f64 y (*.f64 z (log.f64 t))) b)) (*.f64 (/.f64 x b) (/.f64 (-.f64 y (*.f64 z (log.f64 t))) b)))))
(pow.f64 (/.f64 (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))))) (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t)))) (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y))) (*.f64 b (*.f64 b b))) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (*.f64 (/.f64 z (/.f64 b (log.f64 t))) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))))
(*.f64 (-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 b b)) (pow.f64 (/.f64 z (/.f64 b (log.f64 t))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (/.f64 (+.f64 x y) b) (/.f64 z (/.f64 b (log.f64 t))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 t) b)) #s(literal -1 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 (/.f64 #s(literal 1 binary64) t))) (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))
(neg.f64 (-.f64 #s(literal 0 binary64) (/.f64 b (log.f64 t))))
(/.f64 b (log.f64 t))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 t) b))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (log.f64 t) b) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (log.f64 t) b))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 t) b)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 (log.f64 t) b) #s(literal 1 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) b) (log.f64 (/.f64 #s(literal 1 binary64) t)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) b)) (log.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) t))))
(/.f64 (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) b))) (neg.f64 (log.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) t)))))
(pow.f64 (/.f64 b (log.f64 t)) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 t) b) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (log.f64 t) b) #s(literal 1 binary64)) #s(literal -1 binary64))
(*.f64 b (/.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 #s(literal 1 binary64) (/.f64 b (log.f64 t)))
(*.f64 (/.f64 b (log.f64 t)) #s(literal 1 binary64))
(*.f64 (-.f64 #s(literal 0 binary64) b) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) t))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 t)) b)
(*.f64 (pow.f64 (/.f64 #s(literal -1 binary64) b) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal 1 binary64) t))))
(exp.f64 (*.f64 (log.f64 (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64)))) #s(literal -1 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (-.f64 #s(literal 0 binary64) (*.f64 a a))) (*.f64 #s(literal 1/4 binary64) (/.f64 b (*.f64 a a))))
(neg.f64 (*.f64 #s(literal 1/4 binary64) (/.f64 b (*.f64 a a))))
(neg.f64 (/.f64 (*.f64 b #s(literal 1/4 binary64)) (*.f64 a a)))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 a (*.f64 b (/.f64 #s(literal -1/4 binary64) a))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))))))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))) #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 a (*.f64 b (/.f64 #s(literal -1/4 binary64) a)))))
(/.f64 (*.f64 b #s(literal 1/4 binary64)) (-.f64 #s(literal 0 binary64) (*.f64 a a)))
(/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64)) (*.f64 a a))
(/.f64 (*.f64 b (/.f64 #s(literal -1/4 binary64) a)) a)
(/.f64 (neg.f64 (*.f64 b #s(literal 1/4 binary64))) (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 a a))))
(/.f64 (neg.f64 (*.f64 b (/.f64 #s(literal -1/4 binary64) a))) (neg.f64 a))
(/.f64 (neg.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))) (-.f64 #s(literal 0 binary64) (*.f64 a a)))
(/.f64 (*.f64 (/.f64 b a) #s(literal -1/4 binary64)) a)
(/.f64 (neg.f64 (neg.f64 (*.f64 b #s(literal 1/4 binary64)))) (neg.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 a a)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 b (/.f64 #s(literal -1/4 binary64) a)))) (neg.f64 (neg.f64 a)))
(/.f64 (neg.f64 (*.f64 (/.f64 b a) #s(literal -1/4 binary64))) (neg.f64 a))
(pow.f64 (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 a (*.f64 b (/.f64 #s(literal -1/4 binary64) a))) #s(literal -1 binary64))
(*.f64 b (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))
(*.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))
(*.f64 #s(literal -1/4 binary64) (*.f64 b (/.f64 #s(literal 1 binary64) (*.f64 a a))))
(*.f64 #s(literal -1/4 binary64) (/.f64 b (*.f64 a a)))
(*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 a a)))
(*.f64 (*.f64 b #s(literal 1/4 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 a a))))
(*.f64 (/.f64 b a) (/.f64 #s(literal -1/4 binary64) a))
(*.f64 (/.f64 #s(literal -1/4 binary64) a) (/.f64 b a))
(*.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 #s(literal 0 binary64) b) (*.f64 a a)))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 a a)) (*.f64 b #s(literal -1/4 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (*.f64 a a)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 b #s(literal -1/4 binary64))) #s(literal -1 binary64)))
(*.f64 (*.f64 b (/.f64 #s(literal -1/4 binary64) a)) (/.f64 #s(literal 1 binary64) a))
(*.f64 (/.f64 #s(literal -1/4 binary64) (*.f64 a a)) b)
(*.f64 (/.f64 #s(literal 1 binary64) a) (*.f64 b (/.f64 #s(literal -1/4 binary64) a)))
(*.f64 (/.f64 b (neg.f64 a)) (/.f64 #s(literal 1/4 binary64) a))
(*.f64 (/.f64 b #s(literal -1 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 a a)))
(*.f64 (/.f64 #s(literal 1/4 binary64) a) (/.f64 b (neg.f64 a)))
(*.f64 (/.f64 (-.f64 #s(literal 0 binary64) b) a) (/.f64 #s(literal -1/4 binary64) (neg.f64 a)))
(*.f64 (/.f64 #s(literal -1 binary64) a) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (neg.f64 a)))
(*.f64 (/.f64 #s(literal -1/4 binary64) (neg.f64 a)) (/.f64 (-.f64 #s(literal 0 binary64) b) a))
(+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))
(+.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b)
(-.f64 (/.f64 (*.f64 b b) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (/.f64 (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a)) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))))
(-.f64 (/.f64 (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a)) (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b)) (/.f64 (*.f64 b b) (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b)))
(fma.f64 b #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))
(fma.f64 b (/.f64 #s(literal -1/4 binary64) (*.f64 a a)) b)
(fma.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b)
(fma.f64 #s(literal -1/4 binary64) (*.f64 b (/.f64 #s(literal 1 binary64) (*.f64 a a))) b)
(fma.f64 #s(literal -1/4 binary64) (/.f64 b (*.f64 a a)) b)
(fma.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 a a)) b)
(fma.f64 (*.f64 b #s(literal 1/4 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 0 binary64) (*.f64 a a))) b)
(fma.f64 (/.f64 b a) (/.f64 #s(literal -1/4 binary64) a) b)
(fma.f64 (/.f64 #s(literal -1/4 binary64) a) (/.f64 b a) b)
(fma.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 #s(literal 0 binary64) b) (*.f64 a a)) b)
(fma.f64 (/.f64 #s(literal 1 binary64) (*.f64 a a)) (*.f64 b #s(literal -1/4 binary64)) b)
(fma.f64 (/.f64 #s(literal 1 binary64) (*.f64 a a)) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 b #s(literal -1/4 binary64))) #s(literal -1 binary64)) b)
(fma.f64 (*.f64 b (/.f64 #s(literal -1/4 binary64) a)) (/.f64 #s(literal 1 binary64) a) b)
(fma.f64 (/.f64 #s(literal -1/4 binary64) (*.f64 a a)) b b)
(fma.f64 (/.f64 #s(literal 1 binary64) a) (*.f64 b (/.f64 #s(literal -1/4 binary64) a)) b)
(fma.f64 (/.f64 b (neg.f64 a)) (/.f64 #s(literal 1/4 binary64) a) b)
(fma.f64 (/.f64 b #s(literal -1 binary64)) (/.f64 #s(literal 1/4 binary64) (*.f64 a a)) b)
(fma.f64 (/.f64 #s(literal 1/4 binary64) a) (/.f64 b (neg.f64 a)) b)
(fma.f64 (/.f64 (-.f64 #s(literal 0 binary64) b) a) (/.f64 #s(literal -1/4 binary64) (neg.f64 a)) b)
(fma.f64 (/.f64 #s(literal -1 binary64) a) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (neg.f64 a)) b)
(fma.f64 (/.f64 #s(literal -1/4 binary64) (neg.f64 a)) (/.f64 (-.f64 #s(literal 0 binary64) b) a) b)
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (*.f64 b b) (/.f64 (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b) (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))))) (+.f64 (*.f64 b (*.f64 b b)) (/.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (*.f64 b b) (/.f64 (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b) (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))))) (+.f64 (*.f64 b (*.f64 b b)) (/.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))))))
(/.f64 (+.f64 (*.f64 b (*.f64 b b)) (/.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a))))) (+.f64 (*.f64 b b) (/.f64 (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b) (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))))))
(/.f64 (+.f64 (*.f64 b (*.f64 b b)) (/.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a))))) (+.f64 (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a)) (-.f64 (*.f64 b b) (/.f64 (*.f64 b (*.f64 b #s(literal -1/4 binary64))) (*.f64 a a)))))
(/.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))
(/.f64 (neg.f64 (+.f64 (*.f64 b (*.f64 b b)) (/.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a)))))) (neg.f64 (+.f64 (*.f64 b b) (/.f64 (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b) (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64)))))))
(/.f64 (neg.f64 (+.f64 (*.f64 b (*.f64 b b)) (/.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a)))))) (neg.f64 (+.f64 (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a)) (-.f64 (*.f64 b b) (/.f64 (*.f64 b (*.f64 b #s(literal -1/4 binary64))) (*.f64 a a))))))
(/.f64 (neg.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a)))) (neg.f64 (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))))
(/.f64 (-.f64 (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a)) (*.f64 b b)) (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b))
(/.f64 (neg.f64 (neg.f64 (+.f64 (*.f64 b (*.f64 b b)) (/.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a))))))) (neg.f64 (neg.f64 (+.f64 (*.f64 b b) (/.f64 (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b) (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))))) (neg.f64 (neg.f64 (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))))))
(/.f64 (neg.f64 (-.f64 (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a)) (*.f64 b b))) (neg.f64 (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b)))
(pow.f64 (/.f64 (+.f64 (*.f64 b b) (/.f64 (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b) (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64))))) (+.f64 (*.f64 b (*.f64 b b)) (/.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a)))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a)))) #s(literal -1 binary64))
(*.f64 (+.f64 (*.f64 b (*.f64 b b)) (/.f64 (*.f64 (*.f64 b (*.f64 b b)) #s(literal -1/64 binary64)) (*.f64 (*.f64 a a) (*.f64 (*.f64 a a) (*.f64 a a))))) (/.f64 #s(literal 1 binary64) (+.f64 (*.f64 b b) (/.f64 (-.f64 (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)) b) (/.f64 (*.f64 a a) (*.f64 b #s(literal -1/4 binary64)))))))
(*.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))))

simplify638.0ms (5%)

Memory
-69.8MiB live, 1 028.9MiB allocated
Algorithm
1×egg-herbie
Rules
11 028×accelerator-lowering-fma.f32
11 028×accelerator-lowering-fma.f64
5 748×*-lowering-*.f32
5 748×*-lowering-*.f64
4 836×+-lowering-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
03616609
111766509
237576453
084556159
Stop Event
1×iter limit
1×node limit
Counts
528 → 528
Calls
Call 1
Inputs
(* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(* a b)
(* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))
(* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))
(* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))
(* a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))
(* b (- (+ a (+ (/ x b) (/ y b))) 1/2))
(+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))
(+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))
(+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))
(* b (* z (- (/ 1 b) (/ (log t) b))))
(* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))
(* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))
(* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))
(* b (* z (+ (* -1 (/ (log t) b)) (/ 1 b))))
(* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))
(* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))
(* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))
(- (+ x (+ y z)) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(* b (- a 1/2))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- a 1/2))
(* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ z b)) (* -1 (/ (+ x y) b)))) (* -1 (/ (* z (log t)) b)))))
(* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ z b)) (* -1 (/ (+ x y) b)))) (* -1 (/ (* z (log t)) b)))))
(* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ z b)) (* -1 (/ (+ x y) b)))) (* -1 (/ (* z (log t)) b)))))
(* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
x
(* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))
(* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))
(* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))
x
(* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))
(* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))
(* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))
(* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
y
(* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))
(* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))
(* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))
y
(* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))
(* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))
(* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
a
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))
a
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))
(- (+ a (+ (/ x b) (/ y b))) 1/2)
(- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)
(- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)
(- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)
(* z (- (/ 1 b) (/ (log t) b)))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))
(* z (+ (* -1 (/ (log t) b)) (/ 1 b)))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))
(/ (- (+ x (+ y z)) (* z (log t))) b)
(/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)
(/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)
(/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)
(- a 1/2)
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- a 1/2)
(- (+ a (* -1 (/ (- (+ (* -1 z) (* -1 (+ x y))) (* -1 (* z (log t)))) b))) 1/2)
(- (+ a (* -1 (/ (- (+ (* -1 z) (* -1 (+ x y))) (* -1 (* z (log t)))) b))) 1/2)
(- (+ a (* -1 (/ (- (+ (* -1 z) (* -1 (+ x y))) (* -1 (* z (log t)))) b))) 1/2)
(- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(/ x b)
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))
(/ x b)
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))
(- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(/ y b)
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))
(/ y b)
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ (+ x y) b)
(/ y b)
(+ (/ x b) (/ y b))
(+ (/ x b) (/ y b))
(+ (/ x b) (/ y b))
(/ x b)
(* x (+ (/ 1 b) (/ y (* b x))))
(* x (+ (/ 1 b) (/ y (* b x))))
(* x (+ (/ 1 b) (/ y (* b x))))
(/ x b)
(* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))
(* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))
(* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))
(/ x b)
(+ (/ x b) (/ y b))
(+ (/ x b) (/ y b))
(+ (/ x b) (/ y b))
(/ y b)
(* y (+ (/ 1 b) (/ x (* b y))))
(* y (+ (/ 1 b) (/ x (* b y))))
(* y (+ (/ 1 b) (/ x (* b y))))
(/ y b)
(* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))
(* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))
(* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))
(- (/ z b) 1/2)
(- (+ a (/ z b)) 1/2)
(- (+ a (/ z b)) 1/2)
(- (+ a (/ z b)) 1/2)
a
(* a (- (+ 1 (/ z (* a b))) (* 1/2 (/ 1 a))))
(* a (- (+ 1 (/ z (* a b))) (* 1/2 (/ 1 a))))
(* a (- (+ 1 (/ z (* a b))) (* 1/2 (/ 1 a))))
a
(* -1 (* a (- (* -1 (/ (- (/ z b) 1/2) a)) 1)))
(* -1 (* a (- (* -1 (/ (- (/ z b) 1/2) a)) 1)))
(* -1 (* a (- (* -1 (/ (- (/ z b) 1/2) a)) 1)))
(- a 1/2)
(- (+ a (/ z b)) 1/2)
(- (+ a (/ z b)) 1/2)
(- (+ a (/ z b)) 1/2)
(/ z b)
(* z (- (+ (/ 1 b) (/ a z)) (* 1/2 (/ 1 z))))
(* z (- (+ (/ 1 b) (/ a z)) (* 1/2 (/ 1 z))))
(* z (- (+ (/ 1 b) (/ a z)) (* 1/2 (/ 1 z))))
(/ z b)
(* -1 (* z (- (* -1 (/ (- a 1/2) z)) (/ 1 b))))
(* -1 (* z (- (* -1 (/ (- a 1/2) z)) (/ 1 b))))
(* -1 (* z (- (* -1 (/ (- a 1/2) z)) (/ 1 b))))
(/ z b)
(/ (+ z (* b (- a 1/2))) b)
(/ (+ z (* b (- a 1/2))) b)
(/ (+ z (* b (- a 1/2))) b)
(- a 1/2)
(- (+ a (/ z b)) 1/2)
(- (+ a (/ z b)) 1/2)
(- (+ a (/ z b)) 1/2)
(- a 1/2)
(- (+ a (/ z b)) 1/2)
(- (+ a (/ z b)) 1/2)
(- (+ a (/ z b)) 1/2)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
(* -1/2 b)
x
(+ x (* -1/2 b))
(+ x (* -1/2 b))
(+ x (* -1/2 b))
(* -1/2 b)
(* b (- (/ x b) 1/2))
(* b (- (/ x b) 1/2))
(* b (- (/ x b) 1/2))
(* -1/2 b)
(* -1 (* b (+ 1/2 (* -1 (/ x b)))))
(* -1 (* b (+ 1/2 (* -1 (/ x b)))))
(* -1 (* b (+ 1/2 (* -1 (/ x b)))))
(* -1/2 b)
(+ x (* -1/2 b))
(+ x (* -1/2 b))
(+ x (* -1/2 b))
x
(* x (+ 1 (* -1/2 (/ b x))))
(* x (+ 1 (* -1/2 (/ b x))))
(* x (+ 1 (* -1/2 (/ b x))))
x
(* -1 (* x (- (* 1/2 (/ b x)) 1)))
(* -1 (* x (- (* 1/2 (/ b x)) 1)))
(* -1 (* x (- (* 1/2 (/ b x)) 1)))
(* -1/4 b)
(+ (* -1/4 b) (* (pow a 2) b))
(+ (* -1/4 b) (* (pow a 2) b))
(+ (* -1/4 b) (* (pow a 2) b))
(* (pow a 2) b)
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(* (pow a 2) b)
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(* -1 (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))))
(* -1 (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))))
(* -1 (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))))
(* -1 (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))))
(/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (+ 1/2 a))
(+ x (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (+ 1/2 a)))
(+ x (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (+ 1/2 a)))
(+ x (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (+ 1/2 a)))
x
(* x (+ 1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))))
(* x (+ 1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))))
(* x (+ 1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))))
x
(* -1 (* x (- (* -1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))) 1)))
(* -1 (* x (- (* -1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))) 1)))
(* -1 (* x (- (* -1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))) 1)))
(+ x (* -1/2 b))
(+ x (+ (* -1/2 b) (* a b)))
(+ x (+ (* -1/2 b) (* a b)))
(+ x (+ (* -1/2 b) (* a b)))
(* a b)
(* a (- (+ b (/ x a)) (* 1/2 (/ b a))))
(* a (- (+ b (/ x a)) (* 1/2 (/ b a))))
(* a (- (+ b (/ x a)) (* 1/2 (/ b a))))
(* a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))
x
(+ x (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a)))
(+ x (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a)))
(+ x (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a)))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(* b (+ (/ x b) (/ (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2))))) (+ 1/2 a))))
(* b (+ (/ x b) (/ (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2))))) (+ 1/2 a))))
(* b (+ (/ x b) (/ (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2))))) (+ 1/2 a))))
(* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))
(* -1 (* b (+ (* -1 (/ x b)) (/ (* (pow a 2) (- (* 1/4 (/ 1 (pow a 2))) 1)) (+ 1/2 a)))))
(* -1 (* b (+ (* -1 (/ x b)) (/ (* (pow a 2) (- (* 1/4 (/ 1 (pow a 2))) 1)) (+ 1/2 a)))))
(* -1 (* b (+ (* -1 (/ x b)) (/ (* (pow a 2) (- (* 1/4 (/ 1 (pow a 2))) 1)) (+ 1/2 a)))))
(* -1/2 b)
(+ (* -1/2 b) (* a b))
(+ (* -1/2 b) (* a b))
(+ (* -1/2 b) (* a b))
(* a b)
(* a (+ b (* -1/2 (/ b a))))
(* a (+ b (* -1/2 (/ b a))))
(* a (+ b (* -1/2 (/ b a))))
(* a b)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))
(* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))
(* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))
(* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(pow a 2)
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (* -1 (log (/ 1 t)))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(- 1 (log t))
(- 1 (log t))
(- 1 (log t))
(- 1 (log t))
(- 1 (* -1 (log (/ 1 t))))
(- 1 (* -1 (log (/ 1 t))))
(- 1 (* -1 (log (/ 1 t))))
(- 1 (* -1 (log (/ 1 t))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(log t)
(log t)
(log t)
(log t)
(* -1 (log (/ 1 t)))
(* -1 (log (/ 1 t)))
(* -1 (log (/ 1 t)))
(* -1 (log (/ 1 t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(+ (log -1) (* -1 (log (/ -1 t))))
(+ (log -1) (* -1 (log (/ -1 t))))
(+ (log -1) (* -1 (log (/ -1 t))))
(/ (- (+ x y) (* z (log t))) b)
(/ (- (+ x y) (* z (log t))) b)
(/ (- (+ x y) (* z (log t))) b)
(/ (- (+ x y) (* z (log t))) b)
(/ (- (+ x y) (* z (log t))) b)
(/ (- (+ x y) (* z (log t))) b)
(/ (- (+ x y) (* z (log t))) b)
(/ (- (+ x y) (* z (log t))) b)
(* -1 (/ (- (* -1 (+ x y)) (* -1 (* z (log t)))) b))
(* -1 (/ (- (* -1 (+ x y)) (* -1 (* z (log t)))) b))
(* -1 (/ (- (* -1 (+ x y)) (* -1 (* z (log t)))) b))
(* -1 (/ (- (* -1 (+ x y)) (* -1 (* z (log t)))) b))
(- (/ y b) (/ (* z (log t)) b))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(/ x b)
(* x (- (+ (/ 1 b) (/ y (* b x))) (/ (* z (log t)) (* b x))))
(* x (- (+ (/ 1 b) (/ y (* b x))) (/ (* z (log t)) (* b x))))
(* x (- (+ (/ 1 b) (/ y (* b x))) (/ (* z (log t)) (* b x))))
(/ x b)
(* -1 (* x (- (* -1 (/ (- (/ y b) (/ (* z (log t)) b)) x)) (/ 1 b))))
(* -1 (* x (- (* -1 (/ (- (/ y b) (/ (* z (log t)) b)) x)) (/ 1 b))))
(* -1 (* x (- (* -1 (/ (- (/ y b) (/ (* z (log t)) b)) x)) (/ 1 b))))
(- (/ x b) (/ (* z (log t)) b))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(/ y b)
(* y (- (+ (/ 1 b) (/ x (* b y))) (/ (* z (log t)) (* b y))))
(* y (- (+ (/ 1 b) (/ x (* b y))) (/ (* z (log t)) (* b y))))
(* y (- (+ (/ 1 b) (/ x (* b y))) (/ (* z (log t)) (* b y))))
(/ y b)
(* -1 (* y (- (* -1 (/ (- (/ x b) (/ (* z (log t)) b)) y)) (/ 1 b))))
(* -1 (* y (- (* -1 (/ (- (/ x b) (/ (* z (log t)) b)) y)) (/ 1 b))))
(* -1 (* y (- (* -1 (/ (- (/ x b) (/ (* z (log t)) b)) y)) (/ 1 b))))
(+ (/ x b) (/ y b))
(+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (/ y b)))
(+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (/ y b)))
(+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (/ y b)))
(* -1 (/ (* z (log t)) b))
(* z (- (+ (/ x (* b z)) (/ y (* b z))) (/ (log t) b)))
(* z (- (+ (/ x (* b z)) (/ y (* b z))) (/ (log t) b)))
(* z (- (+ (/ x (* b z)) (/ y (* b z))) (/ (log t) b)))
(* -1 (/ (* z (log t)) b))
(* -1 (* z (- (* -1 (/ (+ (/ x b) (/ y b)) z)) (* -1 (/ (log t) b)))))
(* -1 (* z (- (* -1 (/ (+ (/ x b) (/ y b)) z)) (* -1 (/ (log t) b)))))
(* -1 (* z (- (* -1 (/ (+ (/ x b) (/ y b)) z)) (* -1 (/ (log t) b)))))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(- (+ (/ x b) (/ y b)) (* -1 (/ (* z (log (/ 1 t))) b)))
(- (+ (/ x b) (/ y b)) (* -1 (/ (* z (log (/ 1 t))) b)))
(- (+ (/ x b) (/ y b)) (* -1 (/ (* z (log (/ 1 t))) b)))
(- (+ (/ x b) (/ y b)) (* -1 (/ (* z (log (/ 1 t))) b)))
(- (+ (/ x b) (/ y b)) (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))
(- (+ (/ x b) (/ y b)) (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))
(- (+ (/ x b) (/ y b)) (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))
(- (+ (/ x b) (/ y b)) (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(/ b (log t))
(* -1 (/ b (log (/ 1 t))))
(* -1 (/ b (log (/ 1 t))))
(* -1 (/ b (log (/ 1 t))))
(* -1 (/ b (log (/ 1 t))))
(/ b (+ (log -1) (* -1 (log (/ -1 t)))))
(/ b (+ (log -1) (* -1 (log (/ -1 t)))))
(/ b (+ (log -1) (* -1 (log (/ -1 t)))))
(/ b (+ (log -1) (* -1 (log (/ -1 t)))))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* -1/4 (/ b (pow a 2)))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(* -1 (* b (- (* 1/4 (/ 1 (pow a 2))) 1)))
(* -1 (* b (- (* 1/4 (/ 1 (pow a 2))) 1)))
(* -1 (* b (- (* 1/4 (/ 1 (pow a 2))) 1)))
(* -1 (* b (- (* 1/4 (/ 1 (pow a 2))) 1)))
(* -1/4 (/ b (pow a 2)))
(/ (+ (* -1/4 b) (* (pow a 2) b)) (pow a 2))
(/ (+ (* -1/4 b) (* (pow a 2) b)) (pow a 2))
(/ (+ (* -1/4 b) (* (pow a 2) b)) (pow a 2))
b
(+ b (* -1/4 (/ b (pow a 2))))
(+ b (* -1/4 (/ b (pow a 2))))
(+ b (* -1/4 (/ b (pow a 2))))
b
(+ b (* -1/4 (/ b (pow a 2))))
(+ b (* -1/4 (/ b (pow a 2))))
(+ b (* -1/4 (/ b (pow a 2))))
Outputs
(* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(+ (* a b) (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(* a b)
(*.f64 b a)
(* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))
(*.f64 a (+.f64 b (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) a)))
(* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))
(*.f64 a (+.f64 b (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) a)))
(* a (+ b (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))
(*.f64 a (+.f64 b (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) a)))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) a)))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) a)))
(* b (- (+ a (+ (/ x b) (/ y b))) 1/2))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))))
(+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))
(*.f64 b (+.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))))
(+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))
(*.f64 b (+.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))))
(+ (* b (* z (- (/ 1 b) (/ (log t) b)))) (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)))
(*.f64 b (+.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))))
(* b (* z (- (/ 1 b) (/ (log t) b))))
(*.f64 z (-.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (log.f64 t) b))))
(* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))
(*.f64 z (+.f64 (*.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (/.f64 b z)) (-.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (log.f64 t) b)))))
(* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))
(*.f64 z (+.f64 (*.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (/.f64 b z)) (-.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (log.f64 t) b)))))
(* z (+ (* b (- (/ 1 b) (/ (log t) b))) (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))
(*.f64 z (+.f64 (*.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (/.f64 b z)) (-.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (log.f64 t) b)))))
(* b (* z (+ (* -1 (/ (log t) b)) (/ 1 b))))
(*.f64 z (-.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (log.f64 t) b))))
(* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))
(*.f64 z (+.f64 (*.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (/.f64 b z)) (-.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (log.f64 t) b)))))
(* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))
(*.f64 z (+.f64 (*.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (/.f64 b z)) (-.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (log.f64 t) b)))))
(* -1 (* z (+ (* -1 (* b (+ (* -1 (/ (log t) b)) (/ 1 b)))) (* -1 (/ (* b (- (+ a (+ (/ x b) (/ y b))) 1/2)) z)))))
(*.f64 z (+.f64 (*.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (/.f64 b z)) (-.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (log.f64 t) b)))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 (+.f64 x y) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 (+.f64 z (+.f64 y (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 x (*.f64 z (log.f64 t))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 (+.f64 z (+.f64 y (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 x (*.f64 z (log.f64 t))))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 (+.f64 z (+.f64 y (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 x (*.f64 z (log.f64 t))))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ z b)) (* -1 (/ (+ x y) b)))) (* -1 (/ (* z (log t)) b)))))
(*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 (/.f64 (-.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 y z))) b) (+.f64 a #s(literal -1/2 binary64))))
(* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ z b)) (* -1 (/ (+ x y) b)))) (* -1 (/ (* z (log t)) b)))))
(*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 (/.f64 (-.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 y z))) b) (+.f64 a #s(literal -1/2 binary64))))
(* -1 (* b (- (+ (* -1 (- a 1/2)) (+ (* -1 (/ z b)) (* -1 (/ (+ x y) b)))) (* -1 (/ (* z (log t)) b)))))
(*.f64 (-.f64 #s(literal 0 binary64) b) (-.f64 (/.f64 (-.f64 (*.f64 z (log.f64 t)) (+.f64 x (+.f64 y z))) b) (+.f64 a #s(literal -1/2 binary64))))
(* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+.f64 x (*.f64 b (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))))
(+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+.f64 x (*.f64 b (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))))
(+ x (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+.f64 x (*.f64 b (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))))
x
(* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) (/.f64 b x))))
(* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) (/.f64 b x))))
(* x (+ 1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) (/.f64 b x))))
x
(* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))
(*.f64 x (*.f64 (-.f64 #s(literal -1 binary64) (*.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) (/.f64 b x))) #s(literal -1 binary64)))
(* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))
(*.f64 x (*.f64 (-.f64 #s(literal -1 binary64) (*.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) (/.f64 b x))) #s(literal -1 binary64)))
(* -1 (* x (- (* -1 (/ (* b (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) x)) 1)))
(*.f64 x (*.f64 (-.f64 #s(literal -1 binary64) (*.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) (/.f64 b x))) #s(literal -1 binary64)))
(* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+.f64 y (*.f64 b (+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))))
(+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+.f64 y (*.f64 b (+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))))
(+ y (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))))
(+.f64 y (*.f64 b (+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))))
y
(* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) y)))
(* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) y)))
(* y (+ 1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) y)))
y
(* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) y)) (-.f64 #s(literal 0 binary64) y))
(* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) y)) (-.f64 #s(literal 0 binary64) y))
(* -1 (* y (- (* -1 (/ (* b (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (*.f64 b (+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))) y)) (-.f64 #s(literal 0 binary64) y))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b)))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (+.f64 (/.f64 z b) a))) (+.f64 #s(literal -1/2 binary64) (*.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (log.f64 #s(literal -1 binary64))) (/.f64 z b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (+.f64 (/.f64 z b) a))) (+.f64 #s(literal -1/2 binary64) (*.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (log.f64 #s(literal -1 binary64))) (/.f64 z b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (+.f64 (/.f64 z b) a))) (+.f64 #s(literal -1/2 binary64) (*.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (log.f64 #s(literal -1 binary64))) (/.f64 z b)))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))))
(*.f64 b (+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (+.f64 (/.f64 z b) a))) (+.f64 #s(literal -1/2 binary64) (*.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (log.f64 #s(literal -1 binary64))) (/.f64 z b)))))
(- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
a
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))
(*.f64 a (+.f64 (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 x b) a)) (/.f64 y (*.f64 b a))) (/.f64 z (*.f64 b a))) (-.f64 (/.f64 #s(literal -1/2 binary64) a) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b a)))))
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))
(*.f64 a (+.f64 (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 x b) a)) (/.f64 y (*.f64 b a))) (/.f64 z (*.f64 b a))) (-.f64 (/.f64 #s(literal -1/2 binary64) a) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b a)))))
(* a (- (+ 1 (+ (/ x (* a b)) (+ (/ y (* a b)) (/ z (* a b))))) (+ (* 1/2 (/ 1 a)) (/ (* z (log t)) (* a b)))))
(*.f64 a (+.f64 (+.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 (/.f64 x b) a)) (/.f64 y (*.f64 b a))) (/.f64 z (*.f64 b a))) (-.f64 (/.f64 #s(literal -1/2 binary64) a) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b a)))))
a
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) a)) (-.f64 #s(literal 0 binary64) a))
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) a)) (-.f64 #s(literal 0 binary64) a))
(* -1 (* a (- (* -1 (/ (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) a)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 (/.f64 x b) (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) a)) (-.f64 #s(literal 0 binary64) a))
(- (+ a (+ (/ x b) (/ y b))) 1/2)
(+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64)))
(- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)
(+.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
(- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)
(+.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
(- (+ a (+ (* z (- (/ 1 b) (/ (log t) b))) (+ (/ x b) (/ y b)))) 1/2)
(+.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
(* z (- (/ 1 b) (/ (log t) b)))
(*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (-.f64 (+.f64 (/.f64 y (*.f64 b z)) (+.f64 (/.f64 a z) (/.f64 x (*.f64 b z)))) (/.f64 (log.f64 t) b)) (/.f64 #s(literal -1/2 binary64) z))))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (-.f64 (+.f64 (/.f64 y (*.f64 b z)) (+.f64 (/.f64 a z) (/.f64 x (*.f64 b z)))) (/.f64 (log.f64 t) b)) (/.f64 #s(literal -1/2 binary64) z))))
(* z (- (+ (/ 1 b) (+ (/ a z) (+ (/ x (* b z)) (/ y (* b z))))) (+ (* 1/2 (/ 1 z)) (/ (log t) b))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (-.f64 (+.f64 (/.f64 y (*.f64 b z)) (+.f64 (/.f64 a z) (/.f64 x (*.f64 b z)))) (/.f64 (log.f64 t) b)) (/.f64 #s(literal -1/2 binary64) z))))
(* z (+ (* -1 (/ (log t) b)) (/ 1 b)))
(*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))
(*.f64 z (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) z) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))
(*.f64 z (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) z) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
(* -1 (* z (- (* -1 (/ (- (+ a (+ (/ x b) (/ y b))) 1/2) z)) (+ (* -1 (/ (log t) b)) (/ 1 b)))))
(*.f64 z (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 x b) a) (+.f64 (/.f64 y b) #s(literal -1/2 binary64))) z) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
(/ (- (+ x (+ y z)) (* z (log t))) b)
(/.f64 (+.f64 (+.f64 x y) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) b)
(/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)
(/.f64 (+.f64 (+.f64 z (+.f64 y (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 x (*.f64 z (log.f64 t)))) b)
(/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)
(/.f64 (+.f64 (+.f64 z (+.f64 y (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 x (*.f64 z (log.f64 t)))) b)
(/ (- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t))) b)
(/.f64 (+.f64 (+.f64 z (+.f64 y (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 x (*.f64 z (log.f64 t)))) b)
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
(- (+ a (* -1 (/ (- (+ (* -1 z) (* -1 (+ x y))) (* -1 (* z (log t)))) b))) 1/2)
(+.f64 (/.f64 (+.f64 z (+.f64 x (-.f64 y (*.f64 z (log.f64 t))))) b) (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (* -1 (/ (- (+ (* -1 z) (* -1 (+ x y))) (* -1 (* z (log t)))) b))) 1/2)
(+.f64 (/.f64 (+.f64 z (+.f64 x (-.f64 y (*.f64 z (log.f64 t))))) b) (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (* -1 (/ (- (+ (* -1 z) (* -1 (+ x y))) (* -1 (* z (log t)))) b))) 1/2)
(+.f64 (/.f64 (+.f64 z (+.f64 x (-.f64 y (*.f64 z (log.f64 t))))) b) (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(/ x b)
(/.f64 x b)
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))
(*.f64 x (-.f64 (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (/.f64 z (*.f64 b x)) (+.f64 (/.f64 a x) (/.f64 y (*.f64 b x)))) (/.f64 #s(literal -1/2 binary64) x))) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b x))))
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))
(*.f64 x (-.f64 (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (/.f64 z (*.f64 b x)) (+.f64 (/.f64 a x) (/.f64 y (*.f64 b x)))) (/.f64 #s(literal -1/2 binary64) x))) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b x))))
(* x (- (+ (/ 1 b) (+ (/ a x) (+ (/ y (* b x)) (/ z (* b x))))) (+ (* 1/2 (/ 1 x)) (/ (* z (log t)) (* b x)))))
(*.f64 x (-.f64 (+.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 (+.f64 (/.f64 z (*.f64 b x)) (+.f64 (/.f64 a x) (/.f64 y (*.f64 b x)))) (/.f64 #s(literal -1/2 binary64) x))) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b x))))
(/ x b)
(/.f64 x b)
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))
(*.f64 x (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) x) (/.f64 #s(literal 1 binary64) b)))
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))
(*.f64 x (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) x) (/.f64 #s(literal 1 binary64) b)))
(* -1 (* x (- (* -1 (/ (- (+ a (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) x)) (/ 1 b))))
(*.f64 x (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) x) (/.f64 #s(literal 1 binary64) b)))
(- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(/ y b)
(/.f64 y b)
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))
(*.f64 y (+.f64 (+.f64 (/.f64 z (*.f64 b y)) (+.f64 (/.f64 a y) (/.f64 x (*.f64 b y)))) (+.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (/.f64 #s(literal -1/2 binary64) y) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b y))))))
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))
(*.f64 y (+.f64 (+.f64 (/.f64 z (*.f64 b y)) (+.f64 (/.f64 a y) (/.f64 x (*.f64 b y)))) (+.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (/.f64 #s(literal -1/2 binary64) y) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b y))))))
(* y (- (+ (/ 1 b) (+ (/ a y) (+ (/ x (* b y)) (/ z (* b y))))) (+ (* 1/2 (/ 1 y)) (/ (* z (log t)) (* b y)))))
(*.f64 y (+.f64 (+.f64 (/.f64 z (*.f64 b y)) (+.f64 (/.f64 a y) (/.f64 x (*.f64 b y)))) (+.f64 (/.f64 #s(literal 1 binary64) b) (-.f64 (/.f64 #s(literal -1/2 binary64) y) (/.f64 (*.f64 z (log.f64 t)) (*.f64 b y))))))
(/ y b)
(/.f64 y b)
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))
(*.f64 y (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) y) (/.f64 #s(literal 1 binary64) b)))
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))
(*.f64 y (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) y) (/.f64 #s(literal 1 binary64) b)))
(* -1 (* y (- (* -1 (/ (- (+ a (+ (/ x b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))) y)) (/ 1 b))))
(*.f64 y (+.f64 (/.f64 (+.f64 (+.f64 (/.f64 x b) (/.f64 z b)) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b)))) y) (/.f64 #s(literal 1 binary64) b)))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (* -1 (/ (* z (log (/ 1 t))) b))))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (/.f64 z b))) (+.f64 a (-.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 z (log.f64 t)) b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (+.f64 (/.f64 z b) a))) (+.f64 #s(literal -1/2 binary64) (*.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (log.f64 #s(literal -1 binary64))) (/.f64 z b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (+.f64 (/.f64 z b) a))) (+.f64 #s(literal -1/2 binary64) (*.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (log.f64 #s(literal -1 binary64))) (/.f64 z b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (+.f64 (/.f64 z b) a))) (+.f64 #s(literal -1/2 binary64) (*.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (log.f64 #s(literal -1 binary64))) (/.f64 z b))))
(- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b)))
(+.f64 (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (+.f64 (/.f64 z b) a))) (+.f64 #s(literal -1/2 binary64) (*.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (log.f64 #s(literal -1 binary64))) (/.f64 z b))))
(/ (+ x y) b)
(/.f64 (+.f64 x y) b)
(/ (+ x y) b)
(/.f64 (+.f64 x y) b)
(/ (+ x y) b)
(/.f64 (+.f64 x y) b)
(/ (+ x y) b)
(/.f64 (+.f64 x y) b)
(/ (+ x y) b)
(/.f64 (+.f64 x y) b)
(/ (+ x y) b)
(/.f64 (+.f64 x y) b)
(/ (+ x y) b)
(/.f64 (+.f64 x y) b)
(/ (+ x y) b)
(/.f64 (+.f64 x y) b)
(/ (+ x y) b)
(/.f64 (+.f64 x y) b)
(/ (+ x y) b)
(/.f64 (+.f64 x y) b)
(/ (+ x y) b)
(/.f64 (+.f64 x y) b)
(/ (+ x y) b)
(/.f64 (+.f64 x y) b)
(/ y b)
(/.f64 y b)
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(/ x b)
(/.f64 x b)
(* x (+ (/ 1 b) (/ y (* b x))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 y (*.f64 b x))))
(* x (+ (/ 1 b) (/ y (* b x))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 y (*.f64 b x))))
(* x (+ (/ 1 b) (/ y (* b x))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 y (*.f64 b x))))
(/ x b)
(/.f64 x b)
(* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 y (*.f64 b x))))
(* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 y (*.f64 b x))))
(* -1 (* x (- (* -1 (/ y (* b x))) (/ 1 b))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 y (*.f64 b x))))
(/ x b)
(/.f64 x b)
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(/ y b)
(/.f64 y b)
(* y (+ (/ 1 b) (/ x (* b y))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 x (*.f64 b y))))
(* y (+ (/ 1 b) (/ x (* b y))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 x (*.f64 b y))))
(* y (+ (/ 1 b) (/ x (* b y))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 x (*.f64 b y))))
(/ y b)
(/.f64 y b)
(* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 x (*.f64 b y))))
(* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 x (*.f64 b y))))
(* -1 (* y (- (* -1 (/ x (* b y))) (/ 1 b))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 x (*.f64 b y))))
(- (/ z b) 1/2)
(+.f64 (/.f64 z b) #s(literal -1/2 binary64))
(- (+ a (/ z b)) 1/2)
(+.f64 (+.f64 (/.f64 z b) a) #s(literal -1/2 binary64))
(- (+ a (/ z b)) 1/2)
(+.f64 (+.f64 (/.f64 z b) a) #s(literal -1/2 binary64))
(- (+ a (/ z b)) 1/2)
(+.f64 (+.f64 (/.f64 z b) a) #s(literal -1/2 binary64))
a
(* a (- (+ 1 (/ z (* a b))) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 (/.f64 z b) #s(literal -1/2 binary64)) a)))
(* a (- (+ 1 (/ z (* a b))) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 (/.f64 z b) #s(literal -1/2 binary64)) a)))
(* a (- (+ 1 (/ z (* a b))) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 (/.f64 z b) #s(literal -1/2 binary64)) a)))
a
(* -1 (* a (- (* -1 (/ (- (/ z b) 1/2) a)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (/.f64 z b) #s(literal -1/2 binary64)) a)) (-.f64 #s(literal 0 binary64) a))
(* -1 (* a (- (* -1 (/ (- (/ z b) 1/2) a)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (/.f64 z b) #s(literal -1/2 binary64)) a)) (-.f64 #s(literal 0 binary64) a))
(* -1 (* a (- (* -1 (/ (- (/ z b) 1/2) a)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (/.f64 z b) #s(literal -1/2 binary64)) a)) (-.f64 #s(literal 0 binary64) a))
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
(- (+ a (/ z b)) 1/2)
(+.f64 (+.f64 (/.f64 z b) a) #s(literal -1/2 binary64))
(- (+ a (/ z b)) 1/2)
(+.f64 (+.f64 (/.f64 z b) a) #s(literal -1/2 binary64))
(- (+ a (/ z b)) 1/2)
(+.f64 (+.f64 (/.f64 z b) a) #s(literal -1/2 binary64))
(/ z b)
(/.f64 z b)
(* z (- (+ (/ 1 b) (/ a z)) (* 1/2 (/ 1 z))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (+.f64 a #s(literal -1/2 binary64)) z)))
(* z (- (+ (/ 1 b) (/ a z)) (* 1/2 (/ 1 z))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (+.f64 a #s(literal -1/2 binary64)) z)))
(* z (- (+ (/ 1 b) (/ a z)) (* 1/2 (/ 1 z))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (+.f64 a #s(literal -1/2 binary64)) z)))
(/ z b)
(/.f64 z b)
(* -1 (* z (- (* -1 (/ (- a 1/2) z)) (/ 1 b))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (+.f64 a #s(literal -1/2 binary64)) z)))
(* -1 (* z (- (* -1 (/ (- a 1/2) z)) (/ 1 b))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (+.f64 a #s(literal -1/2 binary64)) z)))
(* -1 (* z (- (* -1 (/ (- a 1/2) z)) (/ 1 b))))
(*.f64 z (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (+.f64 a #s(literal -1/2 binary64)) z)))
(/ z b)
(/.f64 z b)
(/ (+ z (* b (- a 1/2))) b)
(/.f64 (+.f64 z (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) b)
(/ (+ z (* b (- a 1/2))) b)
(/.f64 (+.f64 z (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) b)
(/ (+ z (* b (- a 1/2))) b)
(/.f64 (+.f64 z (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) b)
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
(- (+ a (/ z b)) 1/2)
(+.f64 (+.f64 (/.f64 z b) a) #s(literal -1/2 binary64))
(- (+ a (/ z b)) 1/2)
(+.f64 (+.f64 (/.f64 z b) a) #s(literal -1/2 binary64))
(- (+ a (/ z b)) 1/2)
(+.f64 (+.f64 (/.f64 z b) a) #s(literal -1/2 binary64))
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
(- (+ a (/ z b)) 1/2)
(+.f64 (+.f64 (/.f64 z b) a) #s(literal -1/2 binary64))
(- (+ a (/ z b)) 1/2)
(+.f64 (+.f64 (/.f64 z b) a) #s(literal -1/2 binary64))
(- (+ a (/ z b)) 1/2)
(+.f64 (+.f64 (/.f64 z b) a) #s(literal -1/2 binary64))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
x
(+ x (* -1/2 b))
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+ x (* -1/2 b))
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+ x (* -1/2 b))
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* b (- (/ x b) 1/2))
(*.f64 b (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))
(* b (- (/ x b) 1/2))
(*.f64 b (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))
(* b (- (/ x b) 1/2))
(*.f64 b (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* -1 (* b (+ 1/2 (* -1 (/ x b)))))
(*.f64 b (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))
(* -1 (* b (+ 1/2 (* -1 (/ x b)))))
(*.f64 b (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))
(* -1 (* b (+ 1/2 (* -1 (/ x b)))))
(*.f64 b (+.f64 (/.f64 x b) #s(literal -1/2 binary64)))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(+ x (* -1/2 b))
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+ x (* -1/2 b))
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+ x (* -1/2 b))
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
x
(* x (+ 1 (* -1/2 (/ b x))))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
(* x (+ 1 (* -1/2 (/ b x))))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
(* x (+ 1 (* -1/2 (/ b x))))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
x
(* -1 (* x (- (* 1/2 (/ b x)) 1)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
(* -1 (* x (- (* 1/2 (/ b x)) 1)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
(* -1 (* x (- (* 1/2 (/ b x)) 1)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
(* -1/4 b)
(*.f64 b #s(literal -1/4 binary64))
(+ (* -1/4 b) (* (pow a 2) b))
(*.f64 b (+.f64 #s(literal -1/4 binary64) (*.f64 a a)))
(+ (* -1/4 b) (* (pow a 2) b))
(*.f64 b (+.f64 #s(literal -1/4 binary64) (*.f64 a a)))
(+ (* -1/4 b) (* (pow a 2) b))
(*.f64 b (+.f64 #s(literal -1/4 binary64) (*.f64 a a)))
(* (pow a 2) b)
(*.f64 b (*.f64 a a))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* (pow a 2) b)
(*.f64 b (*.f64 a a))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* (pow a 2) (+ b (* -1/4 (/ b (pow a 2)))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2))))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* -1 (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* -1 (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* -1 (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(* -1 (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))))
(*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))))
(/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (+ 1/2 a))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(+ x (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (+ 1/2 a)))
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a)))
(+ x (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (+ 1/2 a)))
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a)))
(+ x (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (+ 1/2 a)))
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a)))
x
(* x (+ 1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 (*.f64 a a) (/.f64 (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) (*.f64 x (+.f64 #s(literal 1/2 binary64) a))))))
(* x (+ 1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 (*.f64 a a) (/.f64 (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) (*.f64 x (+.f64 #s(literal 1/2 binary64) a))))))
(* x (+ 1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 (*.f64 a a) (/.f64 (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) (*.f64 x (+.f64 #s(literal 1/2 binary64) a))))))
x
(* -1 (* x (- (* -1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 x (-.f64 #s(literal -1 binary64) (*.f64 (*.f64 a a) (/.f64 (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) (*.f64 x (+.f64 #s(literal 1/2 binary64) a)))))))
(* -1 (* x (- (* -1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 x (-.f64 #s(literal -1 binary64) (*.f64 (*.f64 a a) (/.f64 (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) (*.f64 x (+.f64 #s(literal 1/2 binary64) a)))))))
(* -1 (* x (- (* -1 (/ (* (pow a 2) (+ b (* -1/4 (/ b (pow a 2))))) (* x (+ 1/2 a)))) 1)))
(-.f64 #s(literal 0 binary64) (*.f64 x (-.f64 #s(literal -1 binary64) (*.f64 (*.f64 a a) (/.f64 (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) (*.f64 x (+.f64 #s(literal 1/2 binary64) a)))))))
(+ x (* -1/2 b))
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+ x (+ (* -1/2 b) (* a b)))
(+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(+ x (+ (* -1/2 b) (* a b)))
(+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(+ x (+ (* -1/2 b) (* a b)))
(+.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(* a b)
(*.f64 b a)
(* a (- (+ b (/ x a)) (* 1/2 (/ b a))))
(*.f64 a (+.f64 b (/.f64 (+.f64 x (*.f64 b #s(literal -1/2 binary64))) a)))
(* a (- (+ b (/ x a)) (* 1/2 (/ b a))))
(*.f64 a (+.f64 b (/.f64 (+.f64 x (*.f64 b #s(literal -1/2 binary64))) a)))
(* a (- (+ b (/ x a)) (* 1/2 (/ b a))))
(*.f64 a (+.f64 b (/.f64 (+.f64 x (*.f64 b #s(literal -1/2 binary64))) a)))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 x (*.f64 b #s(literal -1/2 binary64))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 x (*.f64 b #s(literal -1/2 binary64))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- x (* 1/2 b)) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 x (*.f64 b #s(literal -1/2 binary64))) a)))
x
(+ x (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a)))
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a)))
(+ x (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a)))
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a)))
(+ x (/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a)))
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a)))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(* b (+ (/ x b) (/ (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2))))) (+ 1/2 a))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
(* b (+ (/ x b) (/ (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2))))) (+ 1/2 a))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
(* b (+ (/ x b) (/ (* (pow a 2) (- 1 (* 1/4 (/ 1 (pow a 2))))) (+ 1/2 a))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
(* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(* -1 (* b (+ (* -1 (/ x b)) (/ (* (pow a 2) (- (* 1/4 (/ 1 (pow a 2))) 1)) (+ 1/2 a)))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
(* -1 (* b (+ (* -1 (/ x b)) (/ (* (pow a 2) (- (* 1/4 (/ 1 (pow a 2))) 1)) (+ 1/2 a)))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
(* -1 (* b (+ (* -1 (/ x b)) (/ (* (pow a 2) (- (* 1/4 (/ 1 (pow a 2))) 1)) (+ 1/2 a)))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(+ (* -1/2 b) (* a b))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(+ (* -1/2 b) (* a b))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(+ (* -1/2 b) (* a b))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* a b)
(*.f64 b a)
(* a (+ b (* -1/2 (/ b a))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* a (+ b (* -1/2 (/ b a))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* a (+ b (* -1/2 (/ b a))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a)))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(/ (* (pow a 2) (* b (- 1 (* 1/4 (/ 1 (pow a 2)))))) (+ 1/2 a))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(* -1 (/ (* (pow a 2) (* b (- (* 1/4 (/ 1 (pow a 2))) 1))) (+ 1/2 a)))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(pow a 2)
(*.f64 a a)
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (* -1 (log (/ 1 t)))))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(*.f64 z (+.f64 (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(* z (- 1 (log t)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (* -1 (log (/ 1 t))))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (* -1 (log (/ 1 t))))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (* -1 (log (/ 1 t))))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (* -1 (log (/ 1 t))))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(+.f64 (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(+.f64 (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(+.f64 (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- 1 (+ (log -1) (* -1 (log (/ -1 t)))))
(+.f64 (-.f64 #s(literal 1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(log t)
(log.f64 t)
(log t)
(log.f64 t)
(log t)
(log.f64 t)
(log t)
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(* -1 (log (/ 1 t)))
(log.f64 t)
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(+ (log -1) (* -1 (log (/ -1 t))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(/ (- (+ x y) (* z (log t))) b)
(/.f64 (+.f64 x (-.f64 y (*.f64 z (log.f64 t)))) b)
(/ (- (+ x y) (* z (log t))) b)
(/.f64 (+.f64 x (-.f64 y (*.f64 z (log.f64 t)))) b)
(/ (- (+ x y) (* z (log t))) b)
(/.f64 (+.f64 x (-.f64 y (*.f64 z (log.f64 t)))) b)
(/ (- (+ x y) (* z (log t))) b)
(/.f64 (+.f64 x (-.f64 y (*.f64 z (log.f64 t)))) b)
(/ (- (+ x y) (* z (log t))) b)
(/.f64 (+.f64 x (-.f64 y (*.f64 z (log.f64 t)))) b)
(/ (- (+ x y) (* z (log t))) b)
(/.f64 (+.f64 x (-.f64 y (*.f64 z (log.f64 t)))) b)
(/ (- (+ x y) (* z (log t))) b)
(/.f64 (+.f64 x (-.f64 y (*.f64 z (log.f64 t)))) b)
(/ (- (+ x y) (* z (log t))) b)
(/.f64 (+.f64 x (-.f64 y (*.f64 z (log.f64 t)))) b)
(* -1 (/ (- (* -1 (+ x y)) (* -1 (* z (log t)))) b))
(/.f64 (+.f64 x (-.f64 y (*.f64 z (log.f64 t)))) b)
(* -1 (/ (- (* -1 (+ x y)) (* -1 (* z (log t)))) b))
(/.f64 (+.f64 x (-.f64 y (*.f64 z (log.f64 t)))) b)
(* -1 (/ (- (* -1 (+ x y)) (* -1 (* z (log t)))) b))
(/.f64 (+.f64 x (-.f64 y (*.f64 z (log.f64 t)))) b)
(* -1 (/ (- (* -1 (+ x y)) (* -1 (* z (log t)))) b))
(/.f64 (+.f64 x (-.f64 y (*.f64 z (log.f64 t)))) b)
(- (/ y b) (/ (* z (log t)) b))
(-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(/ x b)
(/.f64 x b)
(* x (- (+ (/ 1 b) (/ y (* b x))) (/ (* z (log t)) (* b x))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)) x)))
(* x (- (+ (/ 1 b) (/ y (* b x))) (/ (* z (log t)) (* b x))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)) x)))
(* x (- (+ (/ 1 b) (/ y (* b x))) (/ (* z (log t)) (* b x))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)) x)))
(/ x b)
(/.f64 x b)
(* -1 (* x (- (* -1 (/ (- (/ y b) (/ (* z (log t)) b)) x)) (/ 1 b))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)) x)))
(* -1 (* x (- (* -1 (/ (- (/ y b) (/ (* z (log t)) b)) x)) (/ 1 b))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)) x)))
(* -1 (* x (- (* -1 (/ (- (/ y b) (/ (* z (log t)) b)) x)) (/ 1 b))))
(*.f64 x (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)) x)))
(- (/ x b) (/ (* z (log t)) b))
(-.f64 (/.f64 x b) (/.f64 (*.f64 z (log.f64 t)) b))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(/ y b)
(/.f64 y b)
(* y (- (+ (/ 1 b) (/ x (* b y))) (/ (* z (log t)) (* b y))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 (/.f64 x b) (/.f64 (*.f64 z (log.f64 t)) b)) y)))
(* y (- (+ (/ 1 b) (/ x (* b y))) (/ (* z (log t)) (* b y))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 (/.f64 x b) (/.f64 (*.f64 z (log.f64 t)) b)) y)))
(* y (- (+ (/ 1 b) (/ x (* b y))) (/ (* z (log t)) (* b y))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 (/.f64 x b) (/.f64 (*.f64 z (log.f64 t)) b)) y)))
(/ y b)
(/.f64 y b)
(* -1 (* y (- (* -1 (/ (- (/ x b) (/ (* z (log t)) b)) y)) (/ 1 b))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 (/.f64 x b) (/.f64 (*.f64 z (log.f64 t)) b)) y)))
(* -1 (* y (- (* -1 (/ (- (/ x b) (/ (* z (log t)) b)) y)) (/ 1 b))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 (/.f64 x b) (/.f64 (*.f64 z (log.f64 t)) b)) y)))
(* -1 (* y (- (* -1 (/ (- (/ x b) (/ (* z (log t)) b)) y)) (/ 1 b))))
(*.f64 y (+.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (-.f64 (/.f64 x b) (/.f64 (*.f64 z (log.f64 t)) b)) y)))
(+ (/ x b) (/ y b))
(+.f64 (/.f64 x b) (/.f64 y b))
(+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (/ y b)))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (/ y b)))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (/ y b)))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(* -1 (/ (* z (log t)) b))
(/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))
(* z (- (+ (/ x (* b z)) (/ y (* b z))) (/ (log t) b)))
(*.f64 z (+.f64 (/.f64 x (*.f64 b z)) (-.f64 (/.f64 y (*.f64 b z)) (/.f64 (log.f64 t) b))))
(* z (- (+ (/ x (* b z)) (/ y (* b z))) (/ (log t) b)))
(*.f64 z (+.f64 (/.f64 x (*.f64 b z)) (-.f64 (/.f64 y (*.f64 b z)) (/.f64 (log.f64 t) b))))
(* z (- (+ (/ x (* b z)) (/ y (* b z))) (/ (log t) b)))
(*.f64 z (+.f64 (/.f64 x (*.f64 b z)) (-.f64 (/.f64 y (*.f64 b z)) (/.f64 (log.f64 t) b))))
(* -1 (/ (* z (log t)) b))
(/.f64 (*.f64 z (log.f64 t)) (-.f64 #s(literal 0 binary64) b))
(* -1 (* z (- (* -1 (/ (+ (/ x b) (/ y b)) z)) (* -1 (/ (log t) b)))))
(*.f64 z (-.f64 (/.f64 (+.f64 (/.f64 x b) (/.f64 y b)) z) (/.f64 (log.f64 t) b)))
(* -1 (* z (- (* -1 (/ (+ (/ x b) (/ y b)) z)) (* -1 (/ (log t) b)))))
(*.f64 z (-.f64 (/.f64 (+.f64 (/.f64 x b) (/.f64 y b)) z) (/.f64 (log.f64 t) b)))
(* -1 (* z (- (* -1 (/ (+ (/ x b) (/ y b)) z)) (* -1 (/ (log t) b)))))
(*.f64 z (-.f64 (/.f64 (+.f64 (/.f64 x b) (/.f64 y b)) z) (/.f64 (log.f64 t) b)))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ (/ x b) (/ y b)) (/ (* z (log t)) b))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ (/ x b) (/ y b)) (* -1 (/ (* z (log (/ 1 t))) b)))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ (/ x b) (/ y b)) (* -1 (/ (* z (log (/ 1 t))) b)))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ (/ x b) (/ y b)) (* -1 (/ (* z (log (/ 1 t))) b)))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ (/ x b) (/ y b)) (* -1 (/ (* z (log (/ 1 t))) b)))
(+.f64 (/.f64 x b) (-.f64 (/.f64 y b) (/.f64 (*.f64 z (log.f64 t)) b)))
(- (+ (/ x b) (/ y b)) (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))
(+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (*.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (log.f64 #s(literal -1 binary64))) (/.f64 z b)))
(- (+ (/ x b) (/ y b)) (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))
(+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (*.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (log.f64 #s(literal -1 binary64))) (/.f64 z b)))
(- (+ (/ x b) (/ y b)) (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))
(+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (*.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (log.f64 #s(literal -1 binary64))) (/.f64 z b)))
(- (+ (/ x b) (/ y b)) (/ (* z (+ (log -1) (* -1 (log (/ -1 t))))) b))
(+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (*.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) t)) (log.f64 #s(literal -1 binary64))) (/.f64 z b)))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(/ b (log t))
(/.f64 b (log.f64 t))
(* -1 (/ b (log (/ 1 t))))
(/.f64 b (log.f64 t))
(* -1 (/ b (log (/ 1 t))))
(/.f64 b (log.f64 t))
(* -1 (/ b (log (/ 1 t))))
(/.f64 b (log.f64 t))
(* -1 (/ b (log (/ 1 t))))
(/.f64 b (log.f64 t))
(/ b (+ (log -1) (* -1 (log (/ -1 t)))))
(/.f64 b (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(/ b (+ (log -1) (* -1 (log (/ -1 t)))))
(/.f64 b (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(/ b (+ (log -1) (* -1 (log (/ -1 t)))))
(/.f64 b (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(/ b (+ (log -1) (* -1 (log (/ -1 t)))))
(/.f64 b (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* b (- 1 (* 1/4 (/ 1 (pow a 2)))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* -1 (* b (- (* 1/4 (/ 1 (pow a 2))) 1)))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* -1 (* b (- (* 1/4 (/ 1 (pow a 2))) 1)))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* -1 (* b (- (* 1/4 (/ 1 (pow a 2))) 1)))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* -1 (* b (- (* 1/4 (/ 1 (pow a 2))) 1)))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(* -1/4 (/ b (pow a 2)))
(/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))
(/ (+ (* -1/4 b) (* (pow a 2) b)) (pow a 2))
(/.f64 (*.f64 b (+.f64 #s(literal -1/4 binary64) (*.f64 a a))) (*.f64 a a))
(/ (+ (* -1/4 b) (* (pow a 2) b)) (pow a 2))
(/.f64 (*.f64 b (+.f64 #s(literal -1/4 binary64) (*.f64 a a))) (*.f64 a a))
(/ (+ (* -1/4 b) (* (pow a 2) b)) (pow a 2))
(/.f64 (*.f64 b (+.f64 #s(literal -1/4 binary64) (*.f64 a a))) (*.f64 a a))
b
(+ b (* -1/4 (/ b (pow a 2))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(+ b (* -1/4 (/ b (pow a 2))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(+ b (* -1/4 (/ b (pow a 2))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
b
(+ b (* -1/4 (/ b (pow a 2))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(+ b (* -1/4 (/ b (pow a 2))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))
(+ b (* -1/4 (/ b (pow a 2))))
(*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))

eval160.0ms (1.3%)

Memory
6.3MiB live, 366.1MiB allocated
Compiler

Compiled 33 730 to 2 924 computations (91.3% saved)

prune177.0ms (1.4%)

Memory
1.4MiB live, 387.7MiB allocated
Pruning

45 alts after pruning (37 fresh and 8 done)

PrunedKeptTotal
New1 185151 200
Fresh92231
Picked235
Done055
Total1 196451 241
Accuracy
100.0%
Counts
1 241 → 45
Alt Table
Click to see full alt table
StatusAccuracyProgram
16.8%
(/.f64 (-.f64 (*.f64 x x) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))) (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))
23.1%
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (/.f64 #s(literal 1 binary64) x)))
19.6%
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
21.5%
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) z))
37.2%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
24.3%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
✓20.1%
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
✓77.2%
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
54.1%
(+.f64 (-.f64 (+.f64 z x) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
35.1%
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
✓62.9%
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
✓33.5%
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
60.2%
(+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
44.0%
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
37.6%
(+.f64 y (*.f64 b #s(literal -1/2 binary64)))
42.6%
(+.f64 y x)
22.8%
(+.f64 x (/.f64 (/.f64 (*.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))) (*.f64 a a)) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
28.1%
(+.f64 x (/.f64 (/.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))) (+.f64 a #s(literal 1/2 binary64))))
30.0%
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) a))
35.2%
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) #s(literal 1/2 binary64)))
33.2%
(+.f64 x (/.f64 (*.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) a) (+.f64 a #s(literal 1/2 binary64))))
33.2%
(+.f64 x (/.f64 (*.f64 b #s(literal -1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))))
48.5%
(+.f64 x (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))
40.1%
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
42.2%
(+.f64 x (*.f64 b a))
15.1%
(*.f64 (/.f64 y b) b)
13.8%
(*.f64 (/.f64 x b) b)
21.5%
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (-.f64 #s(literal 1 binary64) (log.f64 t)))
16.7%
(*.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal -1/2 binary64) b) x)))
✓21.5%
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
36.3%
(*.f64 (+.f64 (/.f64 z b) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t))))) b)
51.4%
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 y b)) b)
49.4%
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 x b)) b)
37.3%
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
12.3%
(*.f64 (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))) b)
19.0%
(*.f64 (*.f64 z b) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))
50.1%
(*.f64 x (+.f64 (/.f64 y x) (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) #s(literal 1 binary64))))
31.3%
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
33.4%
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
49.1%
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
24.4%
(*.f64 b a)
71.4%
(*.f64 a (+.f64 (+.f64 b (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (*.f64 z (/.f64 (log.f64 t) a)))))
✓15.3%
(*.f64 #s(literal -1/2 binary64) b)
✓24.4%
y
✓20.2%
x
Compiler

Compiled 1 850 to 848 computations (54.2% saved)

regimes325.0ms (2.5%)

Memory
-6.9MiB live, 544.9MiB allocated
Counts
74 → 1
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b a)
(+.f64 y x)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 b (/.f64 x b))
(*.f64 b (/.f64 y b))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(*.f64 (/.f64 x b) b)
(*.f64 (/.f64 y b) b)
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+.f64 x (*.f64 b a))
(+.f64 y (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b a)))
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
(+.f64 x (/.f64 (*.f64 b #s(literal -1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
(+.f64 x (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) #s(literal 1/2 binary64)))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) a))
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 x b)) b)
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 y b)) b)
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))) b))
(/.f64 (-.f64 (*.f64 x x) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))) (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))
(*.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal -1/2 binary64) b) x)))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(+.f64 x (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) a) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) b) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 x x)) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))
(*.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (/.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (/.f64 (*.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))) (*.f64 a a)) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (/.f64 #s(literal 1 binary64) x)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (-.f64 #s(literal 1 binary64) (log.f64 t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) z))
(*.f64 b (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
(*.f64 (*.f64 z b) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))
(*.f64 (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))) b)
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 (-.f64 (+.f64 z x) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
(*.f64 x (+.f64 (/.f64 y x) (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) #s(literal 1 binary64))))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 (+.f64 (/.f64 z b) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t))))) b)
(+.f64 (*.f64 x (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 z (+.f64 (log.f64 t) #s(literal -1 binary64))) y) x))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (+.f64 x (-.f64 (+.f64 y z) (*.f64 z (log.f64 t)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(*.f64 b (-.f64 (+.f64 (+.f64 (/.f64 x b) (/.f64 y b)) (+.f64 (+.f64 a (/.f64 z b)) #s(literal -1/2 binary64))) (*.f64 z (/.f64 (log.f64 t) b))))
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) b) (+.f64 x y)) (/.f64 z (/.f64 b (log.f64 t))))) b)
(+.f64 (*.f64 x (-.f64 (+.f64 (/.f64 y x) (+.f64 #s(literal 1 binary64) (/.f64 z x))) (*.f64 z (/.f64 (log.f64 t) x)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 (*.f64 y (+.f64 (/.f64 x y) (-.f64 (+.f64 #s(literal 1 binary64) (/.f64 z y)) (*.f64 z (/.f64 (log.f64 t) y))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 a (+.f64 (+.f64 b (+.f64 (/.f64 x a) (+.f64 (/.f64 y a) (/.f64 z a)))) (-.f64 (/.f64 (*.f64 b #s(literal -1/2 binary64)) a) (*.f64 z (/.f64 (log.f64 t) a)))))
(+.f64 (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 z (log.f64 t)))) (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (*.f64 z (log.f64 t))) #s(literal 2 binary64))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
Outputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
Calls

12 calls:

48.0ms
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
32.0ms
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
30.0ms
b
29.0ms
(log.f64 t)
23.0ms
y
Results
AccuracySegmentsBranch
99.8%1x
99.8%1y
99.8%1z
99.8%1t
99.8%1a
99.8%1b
99.8%1(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
99.8%1(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
99.8%1(+.f64 x y)
99.8%1(log.f64 t)
99.8%1(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
99.8%1(-.f64 a #s(literal 1/2 binary64))
Compiler

Compiled 117 to 93 computations (20.5% saved)

regimes224.0ms (1.7%)

Memory
-4.6MiB live, 430.8MiB allocated
Counts
64 → 3
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b a)
(+.f64 y x)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 b (/.f64 x b))
(*.f64 b (/.f64 y b))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(*.f64 (/.f64 x b) b)
(*.f64 (/.f64 y b) b)
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+.f64 x (*.f64 b a))
(+.f64 y (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b a)))
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
(+.f64 x (/.f64 (*.f64 b #s(literal -1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
(+.f64 x (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) #s(literal 1/2 binary64)))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) a))
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 x b)) b)
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 y b)) b)
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))) b))
(/.f64 (-.f64 (*.f64 x x) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))) (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))
(*.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal -1/2 binary64) b) x)))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(+.f64 x (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) a) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) b) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 x x)) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))
(*.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (/.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (/.f64 (*.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))) (*.f64 a a)) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (/.f64 #s(literal 1 binary64) x)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (-.f64 #s(literal 1 binary64) (log.f64 t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) z))
(*.f64 b (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
(*.f64 (*.f64 z b) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))
(*.f64 (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))) b)
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 (-.f64 (+.f64 z x) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
(*.f64 x (+.f64 (/.f64 y x) (+.f64 (*.f64 z (/.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) #s(literal 1 binary64))))
Outputs
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
Calls

11 calls:

22.0ms
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
22.0ms
a
20.0ms
(log.f64 t)
20.0ms
x
20.0ms
z
Results
AccuracySegmentsBranch
85.8%4x
84.1%4y
93.0%3z
78.7%1t
93.3%3a
90.9%3b
85.9%2(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
88.0%3(+.f64 x y)
78.7%1(log.f64 t)
96.6%3(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
93.3%3(-.f64 a #s(literal 1/2 binary64))
Compiler

Compiled 95 to 78 computations (17.9% saved)

regimes47.0ms (0.4%)

Memory
0.9MiB live, 39.5MiB allocated
Counts
62 → 3
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b a)
(+.f64 y x)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 b (/.f64 x b))
(*.f64 b (/.f64 y b))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(*.f64 (/.f64 x b) b)
(*.f64 (/.f64 y b) b)
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+.f64 x (*.f64 b a))
(+.f64 y (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b a)))
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
(+.f64 x (/.f64 (*.f64 b #s(literal -1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
(+.f64 x (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) #s(literal 1/2 binary64)))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) a))
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 x b)) b)
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 y b)) b)
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))) b))
(/.f64 (-.f64 (*.f64 x x) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))) (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))
(*.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal -1/2 binary64) b) x)))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(+.f64 x (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) a) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) b) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 x x)) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))
(*.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (/.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (/.f64 (*.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))) (*.f64 a a)) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (/.f64 #s(literal 1 binary64) x)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (-.f64 #s(literal 1 binary64) (log.f64 t)))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (log.f64 t))) z))
(*.f64 b (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))))
(*.f64 (*.f64 z b) (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b)))
(*.f64 (*.f64 z (-.f64 (/.f64 #s(literal 1 binary64) b) (/.f64 (log.f64 t) b))) b)
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 (-.f64 (+.f64 z x) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64)))
Outputs
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
Calls

1 calls:

17.0ms
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
Results
AccuracySegmentsBranch
94.6%3(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
Compiler

Compiled 11 to 9 computations (18.2% saved)

regimes105.0ms (0.8%)

Memory
23.3MiB live, 102.7MiB allocated
Counts
53 → 3
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b a)
(+.f64 y x)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 b (/.f64 x b))
(*.f64 b (/.f64 y b))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(*.f64 (/.f64 x b) b)
(*.f64 (/.f64 y b) b)
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+.f64 x (*.f64 b a))
(+.f64 y (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b a)))
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
(+.f64 x (/.f64 (*.f64 b #s(literal -1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
(+.f64 x (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) #s(literal 1/2 binary64)))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) a))
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 x b)) b)
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 y b)) b)
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))) b))
(/.f64 (-.f64 (*.f64 x x) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))) (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))
(*.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal -1/2 binary64) b) x)))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(+.f64 x (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) a) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) b) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 x x)) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))
(*.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (/.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (/.f64 (*.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))) (*.f64 a a)) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (/.f64 #s(literal 1 binary64) x)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) z)) (-.f64 #s(literal 1 binary64) (log.f64 t)))
Outputs
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
Calls

5 calls:

34.0ms
(-.f64 a #s(literal 1/2 binary64))
19.0ms
z
15.0ms
a
15.0ms
b
15.0ms
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
Results
AccuracySegmentsBranch
82.8%3b
89.4%3z
78.7%1a
78.7%1(-.f64 a #s(literal 1/2 binary64))
84.2%3(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
Compiler

Compiled 41 to 35 computations (14.6% saved)

regimes26.0ms (0.2%)

Memory
-4.9MiB live, 33.0MiB allocated
Counts
51 → 3
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b a)
(+.f64 y x)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 b (/.f64 x b))
(*.f64 b (/.f64 y b))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(*.f64 (/.f64 x b) b)
(*.f64 (/.f64 y b) b)
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+.f64 x (*.f64 b a))
(+.f64 y (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b a)))
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
(+.f64 x (/.f64 (*.f64 b #s(literal -1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
(+.f64 x (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) #s(literal 1/2 binary64)))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) a))
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 x b)) b)
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 y b)) b)
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))) b))
(/.f64 (-.f64 (*.f64 x x) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))) (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))
(*.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal -1/2 binary64) b) x)))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(+.f64 x (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) a) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) b) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 x x)) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))
(*.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (/.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (/.f64 (*.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))) (*.f64 a a)) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (/.f64 #s(literal 1 binary64) x)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
Outputs
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
Calls

1 calls:

20.0ms
z
Results
AccuracySegmentsBranch
89.1%3z
Compiler

Compiled 7 to 6 computations (14.3% saved)

regimes30.0ms (0.2%)

Memory
-0.7MiB live, 37.1MiB allocated
Counts
50 → 3
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b a)
(+.f64 y x)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 b (/.f64 x b))
(*.f64 b (/.f64 y b))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(*.f64 (/.f64 x b) b)
(*.f64 (/.f64 y b) b)
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+.f64 x (*.f64 b a))
(+.f64 y (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b a)))
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
(+.f64 x (/.f64 (*.f64 b #s(literal -1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
(+.f64 x (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) #s(literal 1/2 binary64)))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) a))
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 x b)) b)
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 y b)) b)
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))) b))
(/.f64 (-.f64 (*.f64 x x) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))) (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))
(*.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal -1/2 binary64) b) x)))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(+.f64 x (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) a) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) b) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 x x)) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))
(*.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (/.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (/.f64 (*.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))) (*.f64 a a)) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (/.f64 #s(literal 1 binary64) x)))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z)
Outputs
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))
Calls

1 calls:

24.0ms
z
Results
AccuracySegmentsBranch
86.2%3z
Compiler

Compiled 7 to 6 computations (14.3% saved)

regimes84.0ms (0.7%)

Memory
-22.6MiB live, 178.9MiB allocated
Counts
48 → 1
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b a)
(+.f64 y x)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 b (/.f64 x b))
(*.f64 b (/.f64 y b))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(*.f64 (/.f64 x b) b)
(*.f64 (/.f64 y b) b)
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+.f64 x (*.f64 b a))
(+.f64 y (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b a)))
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
(+.f64 x (/.f64 (*.f64 b #s(literal -1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(*.f64 x (+.f64 #s(literal 1 binary64) (*.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) x))))
(+.f64 x (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/2 binary64)) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) #s(literal 1/2 binary64)))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) a))
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 x b)) b)
(*.f64 (+.f64 (+.f64 a (+.f64 #s(literal -1/2 binary64) (/.f64 z b))) (/.f64 y b)) b)
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (*.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)))) b))
(/.f64 (-.f64 (*.f64 x x) (*.f64 #s(literal 1/4 binary64) (*.f64 b b))) (-.f64 x (*.f64 #s(literal -1/2 binary64) b)))
(*.f64 (-.f64 (*.f64 #s(literal 1/4 binary64) (*.f64 b b)) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 #s(literal -1/2 binary64) b) x)))
(/.f64 (*.f64 (*.f64 a a) (*.f64 b (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))
(+.f64 x (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (+.f64 (*.f64 a (*.f64 a b)) (*.f64 (*.f64 b #s(literal -1/4 binary64)) #s(literal 1 binary64))))))
(+.f64 x (/.f64 (*.f64 (*.f64 a a) (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 a (+.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) a) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (*.f64 (*.f64 (*.f64 a a) (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a)))) b) (+.f64 a #s(literal 1/2 binary64))))
(*.f64 b (+.f64 (/.f64 x b) (/.f64 (*.f64 a (*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 #s(literal -1/4 binary64) (*.f64 a a))))) (+.f64 #s(literal 1/2 binary64) a))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) b) (*.f64 (+.f64 (*.f64 a a) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (*.f64 (+.f64 (*.f64 a (*.f64 a a)) #s(literal -1/8 binary64)) b) (+.f64 (*.f64 a a) (-.f64 #s(literal 1/4 binary64) (*.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (*.f64 x x)) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) x))
(*.f64 (-.f64 (*.f64 x x) (*.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 x (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 x (/.f64 (/.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) b) (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64)))))) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 x (/.f64 (/.f64 (*.f64 (-.f64 (*.f64 b b) (/.f64 (*.f64 (*.f64 b #s(literal -1/4 binary64)) (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a))) (*.f64 a a))) (*.f64 a a)) (-.f64 b (/.f64 (*.f64 b #s(literal -1/4 binary64)) (*.f64 a a)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (+.f64 (*.f64 (*.f64 (+.f64 (*.f64 (*.f64 a (*.f64 a a)) (*.f64 a (*.f64 a a))) #s(literal -1/64 binary64)) (/.f64 b (+.f64 a #s(literal 1/2 binary64)))) (/.f64 #s(literal 1 binary64) x)) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) #s(literal 1 binary64))) (*.f64 (+.f64 (*.f64 a (*.f64 a (*.f64 a a))) (-.f64 #s(literal 1/16 binary64) (*.f64 a (*.f64 a #s(literal -1/4 binary64))))) (/.f64 #s(literal 1 binary64) x)))
Outputs
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
Calls

5 calls:

20.0ms
x
16.0ms
z
15.0ms
y
14.0ms
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
14.0ms
b
Results
AccuracySegmentsBranch
78.7%1y
78.7%1b
78.7%1(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
78.7%1x
78.7%1z
Compiler

Compiled 39 to 33 computations (15.4% saved)

regimes66.0ms (0.5%)

Memory
31.8MiB live, 149.6MiB allocated
Counts
23 → 2
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b a)
(+.f64 y x)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 b (/.f64 x b))
(*.f64 b (/.f64 y b))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(*.f64 (/.f64 x b) b)
(*.f64 (/.f64 y b) b)
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+.f64 x (*.f64 b a))
(+.f64 y (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (*.f64 b a)))
(*.f64 b (+.f64 a (+.f64 (/.f64 x b) #s(literal -1/2 binary64))))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (*.f64 b #s(literal -1/2 binary64)) x)))
(+.f64 x (/.f64 (*.f64 b #s(literal -1/4 binary64)) (+.f64 a #s(literal 1/2 binary64))))
Outputs
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
Calls

8 calls:

9.0ms
(-.f64 a #s(literal 1/2 binary64))
9.0ms
x
9.0ms
y
8.0ms
z
7.0ms
t
Results
AccuracySegmentsBranch
64.0%3t
71.7%2x
60.2%1a
72.8%3(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
73.9%2y
60.2%1z
60.2%1(-.f64 a #s(literal 1/2 binary64))
69.7%3b
Compiler

Compiled 62 to 53 computations (14.5% saved)

regimes20.0ms (0.2%)

Memory
5.1MiB live, 44.7MiB allocated
Counts
18 → 3
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b a)
(+.f64 y x)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 b (/.f64 x b))
(*.f64 b (/.f64 y b))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(*.f64 (/.f64 x b) b)
(*.f64 (/.f64 y b) b)
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+.f64 x (*.f64 b a))
(+.f64 y (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
Outputs
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 y x)
(+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
Calls

3 calls:

7.0ms
y
6.0ms
x
6.0ms
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
Results
AccuracySegmentsBranch
70.9%3(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
59.8%2x
65.9%2y
Compiler

Compiled 25 to 21 computations (16% saved)

regimes15.0ms (0.1%)

Memory
-11.4MiB live, 29.4MiB allocated
Counts
17 → 4
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b a)
(+.f64 y x)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 b (/.f64 x b))
(*.f64 b (/.f64 y b))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(*.f64 (/.f64 x b) b)
(*.f64 (/.f64 y b) b)
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
(+.f64 x (*.f64 b a))
(+.f64 y (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (*.f64 #s(literal -1/2 binary64) b) x)
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) x))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) y))
Outputs
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(+.f64 x (*.f64 b a))
(+.f64 y x)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
Calls

2 calls:

8.0ms
b
6.0ms
y
Results
AccuracySegmentsBranch
55.7%2y
65.6%4b
Compiler

Compiled 14 to 12 computations (14.3% saved)

regimes19.0ms (0.1%)

Memory
7.3MiB live, 46.9MiB allocated
Counts
12 → 3
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b a)
(+.f64 y x)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 b (/.f64 x b))
(*.f64 b (/.f64 y b))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(*.f64 (/.f64 x b) b)
(*.f64 (/.f64 y b) b)
(+.f64 x (*.f64 b #s(literal -1/2 binary64)))
Outputs
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(+.f64 y x)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
Calls

4 calls:

5.0ms
t
4.0ms
z
4.0ms
a
4.0ms
b
Results
AccuracySegmentsBranch
57.6%5a
48.2%4z
48.1%3t
63.2%3b
Compiler

Compiled 28 to 24 computations (14.3% saved)

regimes12.0ms (0.1%)

Memory
-8.5MiB live, 30.7MiB allocated
Counts
5 → 3
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b a)
(+.f64 y x)
Outputs
(*.f64 b a)
(+.f64 y x)
(*.f64 b a)
Calls

4 calls:

3.0ms
x
3.0ms
b
2.0ms
a
2.0ms
y
Results
AccuracySegmentsBranch
53.8%3a
46.3%3y
46.2%3x
51.8%3b
Compiler

Compiled 28 to 24 computations (14.3% saved)

regimes15.0ms (0.1%)

Memory
-1.4MiB live, 38.0MiB allocated
Counts
4 → 3
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
(*.f64 b a)
Outputs
x
(*.f64 b a)
y
Calls

6 calls:

3.0ms
t
2.0ms
x
2.0ms
y
2.0ms
a
2.0ms
z
Results
AccuracySegmentsBranch
41.1%3x
42.7%3y
30.4%4z
29.9%3t
39.6%4b
43.6%5a
Compiler

Compiled 42 to 36 computations (14.3% saved)

regimes6.0ms (0.1%)

Memory
19.8MiB live, 19.8MiB allocated
Counts
3 → 2
Calls
Call 1
Inputs
x
y
(*.f64 #s(literal -1/2 binary64) b)
Outputs
x
y
Calls

3 calls:

2.0ms
a
2.0ms
y
2.0ms
x
Results
AccuracySegmentsBranch
28.2%3a
36.1%2x
37.9%2y
Compiler

Compiled 21 to 18 computations (14.3% saved)

regimes10.0ms (0.1%)

Memory
-7.0MiB live, 33.0MiB allocated
Accuracy

Total 0.0b remaining (0%)

Threshold costs 0b (0%)

Counts
1 → 1
Calls
Call 1
Inputs
x
Outputs
x
Calls

6 calls:

1.0ms
b
1.0ms
a
1.0ms
y
1.0ms
x
1.0ms
z
Results
AccuracySegmentsBranch
20.2%1a
20.2%1z
20.2%1t
20.2%1x
20.2%1b
20.2%1y
Compiler

Compiled 42 to 36 computations (14.3% saved)

bsearch1.0ms (0%)

Memory
2.8MiB live, 2.8MiB allocated
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
9.458102863991386e+70
5.504543936282227e+74
0.0ms
-2.055837741075009e+202
-3.5072418550820722e+174
Compiler

Compiled 25 to 24 computations (4% saved)

bsearch1.0ms (0%)

Memory
2.3MiB live, 2.3MiB allocated
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
9.458102863991386e+70
5.504543936282227e+74
0.0ms
-1.3995973225957743e+20
-14651498229498584.0
Compiler

Compiled 25 to 24 computations (4% saved)

bsearch40.0ms (0.3%)

Memory
-14.6MiB live, 102.4MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
20.0ms
8.022086971101113e+83
1.5204733756016935e+97
16.0ms
-6.72403749787484e+152
-6.478068827438021e+148
Samples
27.0ms288×0valid
Compiler

Compiled 583 to 456 computations (21.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 16.0ms
ival-sub: 4.0ms (24.3% of total)
ival-log: 4.0ms (24.3% of total)
ival-add: 4.0ms (24.3% of total)
ival-mult: 4.0ms (24.3% of total)
ival-true: 0.0ms (0% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

bsearch104.0ms (0.8%)

Memory
-23.4MiB live, 77.1MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
46.0ms
8.022086971101113e+83
1.5204733756016935e+97
53.0ms
-1.1089396520522075e+178
-3.4398604508010093e+165
Samples
89.0ms320×0valid
Compiler

Compiled 645 to 504 computations (21.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 78.0ms
ival-add: 39.0ms (49.9% of total)
ival-log: 32.0ms (41% of total)
ival-mult: 4.0ms (5.1% of total)
ival-sub: 3.0ms (3.8% of total)
ival-true: 0.0ms (0% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

bsearch46.0ms (0.4%)

Memory
25.1MiB live, 99.6MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
20.0ms
7.335198041352344e+145
4.2977264459173355e+159
21.0ms
-1.1089396520522075e+178
-3.4398604508010093e+165
Samples
29.0ms320×0valid
Compiler

Compiled 605 to 484 computations (20% saved)

Precisions
Click to see histograms. Total time spent on operations: 18.0ms
ival-log: 6.0ms (33.5% of total)
ival-add: 5.0ms (27.9% of total)
ival-mult: 4.0ms (22.3% of total)
ival-sub: 3.0ms (16.7% of total)
ival-true: 0.0ms (0% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

bsearch22.0ms (0.2%)

Memory
-13.6MiB live, 26.1MiB allocated
Algorithm
1×binary-search
Stop Event
1×narrow-enough
Steps
TimeLeftRight
20.0ms
1.2939289304341314e-48
4.458525086958423e-44
Samples
16.0ms128×0valid
Compiler

Compiled 249 to 200 computations (19.7% saved)

Precisions
Click to see histograms. Total time spent on operations: 12.0ms
ival-add: 7.0ms (59% of total)
ival-log: 2.0ms (16.9% of total)
ival-mult: 2.0ms (16.9% of total)
ival-sub: 1.0ms (8.4% of total)
ival-true: 0.0ms (0% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

bsearch0.0ms (0%)

Memory
0.6MiB live, 0.6MiB allocated
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
2.1607947188466644e+82
1.117877068359299e+84
0.0ms
-2.3351286259940087e+204
-2.893409227863942e+203
Compiler

Compiled 25 to 24 computations (4% saved)

bsearch52.0ms (0.4%)

Memory
-11.6MiB live, 97.8MiB allocated
Algorithm
3×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
11.0ms
7.012152225055052e+58
5.219294920577181e+59
19.0ms
-2.1978587685256718e-71
-1.696834743591336e-77
15.0ms
-4.321589437693329e+82
-2.6642400248979625e+81
Samples
32.0ms352×0valid
Compiler

Compiled 523 to 418 computations (20.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 20.0ms
ival-log: 7.0ms (34.8% of total)
ival-add: 5.0ms (24.9% of total)
ival-mult: 5.0ms (24.9% of total)
ival-sub: 3.0ms (14.9% of total)
ival-true: 0.0ms (0% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

bsearch29.0ms (0.2%)

Memory
12.7MiB live, 53.5MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
18.0ms
7.012152225055052e+58
5.219294920577181e+59
9.0ms
-5.7906700889921246e-11
-2.603029490063869e-11
Samples
15.0ms176×0valid
Compiler

Compiled 267 to 222 computations (16.9% saved)

Precisions
Click to see histograms. Total time spent on operations: 9.0ms
ival-add: 3.0ms (33.2% of total)
ival-sub: 2.0ms (22.1% of total)
ival-log: 2.0ms (22.1% of total)
ival-mult: 2.0ms (22.1% of total)
ival-true: 0.0ms (0% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

bsearch32.0ms (0.3%)

Memory
-7.0MiB live, 67.1MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
15.0ms
2.800495146606955e+150
4.813164194963631e+154
13.0ms
-5.0473824285773755e+118
-4.7286749025234904e+117
Samples
20.0ms224×0valid
Compiler

Compiled 305 to 248 computations (18.7% saved)

Precisions
Click to see histograms. Total time spent on operations: 13.0ms
ival-mult: 5.0ms (38.6% of total)
ival-log: 3.0ms (23.2% of total)
ival-add: 3.0ms (23.2% of total)
ival-sub: 2.0ms (15.5% of total)
ival-true: 0.0ms (0% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

bsearch37.0ms (0.3%)

Memory
31.3MiB live, 67.3MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
17.0ms
1.6313008478305026e+75
3.6287996285396656e+79
17.0ms
-2.548815588853926e-306
7.583743658637094e-304
Samples
25.0ms271×0valid
0.0ms1×1valid
Compiler

Compiled 331 to 279 computations (15.7% saved)

Precisions
Click to see histograms. Total time spent on operations: 14.0ms
ival-add: 4.0ms (28.7% of total)
ival-mult: 4.0ms (28.7% of total)
ival-log: 3.0ms (21.5% of total)
ival-sub: 2.0ms (14.4% of total)
adjust: 0.0ms (0% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)

bsearch29.0ms (0.2%)

Memory
-17.3MiB live, 54.2MiB allocated
Algorithm
1×binary-search
Stop Event
1×narrow-enough
Steps
TimeLeftRight
22.0ms
1.2939289304341314e-48
4.458525086958423e-44
Samples
18.0ms128×0valid
Compiler

Compiled 153 to 136 computations (11.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 7.0ms
ival-log: 2.0ms (30.2% of total)
ival-add: 2.0ms (30.2% of total)
ival-mult: 2.0ms (30.2% of total)
ival-sub: 1.0ms (15.1% of total)
ival-true: 0.0ms (0% of total)
...in/eval/compile.rkt:110:19: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

simplify14.0ms (0.1%)

Memory
35.9MiB live, 35.9MiB allocated
Algorithm
1×egg-herbie
Rules
38×+-commutative_binary64
20×*-commutative_binary64
14×sub-neg_binary64
14×if-if-or-not_binary32
8×neg-sub0_binary64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
096311
1146311
2162311
3170311
4174311
Stop Event
1×saturated
Calls
Call 1
Inputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -19999999999999998034949182639283460544144256734780786565889968808867646296533821313806154437159508961349496684207805169279743662082613097640633903818517442685833572570894375386028309322626785049753681920 binary64)) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 100000000000000004188152556421145795899143386664033828314342771180699648 binary64)) (+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64))) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
(if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -100000000000000000000 binary64)) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 100000000000000004188152556421145795899143386664033828314342771180699648 binary64)) (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x)) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
(if (<=.f64 z #s(literal -14500000000000000903229071480703128705961428021446990824489100864126299584374913121695168079206832108519637283725346115127319578985060999243111562477568 binary64)) (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (if (<=.f64 z #s(literal 14999999999999999206500517651480201776577074845923502930893358090172637493230228917427303463518208 binary64)) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(if (<=.f64 z #s(literal -2299999999999999931677937682050073365793141736576300789552929870010170098181347412800117782930114283504817839122453022456439689536460887260504522137094637985447391789056 binary64)) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (if (<=.f64 z #s(literal 14999999999999999206500517651480201776577074845923502930893358090172637493230228917427303463518208 binary64)) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(if (<=.f64 z #s(literal -21000000000000000548917631404118452857619255066975660003097640525956068954800166513050748556080101381485100303528929984311244000597903106115484503777630988537870417920 binary64)) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (if (<=.f64 z #s(literal 2600000000000000048191345640337311361614699256642092508282681008485044570829496693306405140794761630515310072883585415748644341802687546847087739441996806225920 binary64)) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(if (<=.f64 y #s(literal 8838159243424447/200867255532373784442745261542645325315275374222849104412672 binary64)) (+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -1999999999999999977538215750126588953018689196590998459950069697680585223647237336888853938920013796903718410691112844909629852261514762472830507743890852478294863899324781023557461759604328517292041175040 binary64)) (+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 39999999999999998536271862523546296844108572901094271174721455373708346006171549696 binary64)) (+.f64 y x) (+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
(if (<=.f64 b #s(literal -11400000000000000661235347505236286387251546757597094230281391683129777855903301632 binary64)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (if (<=.f64 b #s(literal -7260919251582885/994646472819573284310764496293641680200912301594695434880927953786318994025066751066112 binary64)) (+.f64 x (*.f64 b a)) (if (<=.f64 b #s(literal 139999999999999989346079709825462938729195377918139569274880 binary64)) (+.f64 y x) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(if (<=.f64 b #s(literal -4332790137498831/77371252455336267181195264 binary64)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (if (<=.f64 b #s(literal 115000000000000003991848446516986351976535216231821221036032 binary64)) (+.f64 y x) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(if (<=.f64 a #s(literal -16000000000000000808886843615920541027651792492848052464327703595555724223633366493187734033680995508038673811787218944 binary64)) (*.f64 b a) (if (<=.f64 a #s(literal 420000000000000033380757677273290089352167455508992351255846779441851483170486358146484695282494513417224755996317159248501885136279671869730309707661312 binary64)) (+.f64 y x) (*.f64 b a)))
(if (<=.f64 y #s(literal -5692563374268111/6325070415853456823515479584966165845298645305129441198653167438357198111499854590373761990669910140474596183259900372230931523043306046152094168748148078435047419508642698792639590866940413010663742739952273283392562733857021646831815729864036236135650314266011211548510419206725953204130822734645187695728365866909171712 binary64)) x (if (<=.f64 y #s(literal 28999999999999999217874673251247609961461488715019992246745057957393695678398464 binary64)) (*.f64 b a) y))
(if (<=.f64 y #s(literal 6829486688100709/200867255532373784442745261542645325315275374222849104412672 binary64)) x y)
x
Outputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 (-.f64 (+.f64 z (+.f64 x y)) (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -19999999999999998034949182639283460544144256734780786565889968808867646296533821313806154437159508961349496684207805169279743662082613097640633903818517442685833572570894375386028309322626785049753681920 binary64)) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 100000000000000004188152556421145795899143386664033828314342771180699648 binary64)) (+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64))) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
(if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -19999999999999998034949182639283460544144256734780786565889968808867646296533821313806154437159508961349496684207805169279743662082613097640633903818517442685833572570894375386028309322626785049753681920 binary64)) (+.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) (+.f64 x y)) (if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 100000000000000004188152556421145795899143386664033828314342771180699648 binary64)) (+.f64 (-.f64 (+.f64 z (+.f64 x y)) (*.f64 z (log.f64 t))) (*.f64 b #s(literal -1/2 binary64))) (+.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) (+.f64 x y))))
(if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -100000000000000000000 binary64)) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 100000000000000004188152556421145795899143386664033828314342771180699648 binary64)) (+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (+.f64 y x)) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
(if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -100000000000000000000 binary64)) (+.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) (+.f64 x y)) (if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 100000000000000004188152556421145795899143386664033828314342771180699648 binary64)) (+.f64 (+.f64 x y) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (+.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) (+.f64 x y))))
(if (<=.f64 z #s(literal -14500000000000000903229071480703128705961428021446990824489100864126299584374913121695168079206832108519637283725346115127319578985060999243111562477568 binary64)) (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (if (<=.f64 z #s(literal 14999999999999999206500517651480201776577074845923502930893358090172637493230228917427303463518208 binary64)) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(if (<=.f64 z #s(literal -14500000000000000903229071480703128705961428021446990824489100864126299584374913121695168079206832108519637283725346115127319578985060999243111562477568 binary64)) (+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (if (<=.f64 z #s(literal 14999999999999999206500517651480201776577074845923502930893358090172637493230228917427303463518208 binary64)) (+.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) (+.f64 x y)) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(if (<=.f64 z #s(literal -2299999999999999931677937682050073365793141736576300789552929870010170098181347412800117782930114283504817839122453022456439689536460887260504522137094637985447391789056 binary64)) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (if (<=.f64 z #s(literal 14999999999999999206500517651480201776577074845923502930893358090172637493230228917427303463518208 binary64)) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(if (<=.f64 z #s(literal -2299999999999999931677937682050073365793141736576300789552929870010170098181347412800117782930114283504817839122453022456439689536460887260504522137094637985447391789056 binary64)) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (if (<=.f64 z #s(literal 14999999999999999206500517651480201776577074845923502930893358090172637493230228917427303463518208 binary64)) (+.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) (+.f64 x y)) (+.f64 x (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(if (<=.f64 z #s(literal -21000000000000000548917631404118452857619255066975660003097640525956068954800166513050748556080101381485100303528929984311244000597903106115484503777630988537870417920 binary64)) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (if (<=.f64 z #s(literal 2600000000000000048191345640337311361614699256642092508282681008485044570829496693306405140794761630515310072883585415748644341802687546847087739441996806225920 binary64)) (+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(if (<=.f64 z #s(literal -21000000000000000548917631404118452857619255066975660003097640525956068954800166513050748556080101381485100303528929984311244000597903106115484503777630988537870417920 binary64)) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) (if (<=.f64 z #s(literal 2600000000000000048191345640337311361614699256642092508282681008485044570829496693306405140794761630515310072883585415748644341802687546847087739441996806225920 binary64)) (+.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) (+.f64 x y)) (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(+.f64 (+.f64 y x) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) (+.f64 x y))
(if (<=.f64 y #s(literal 8838159243424447/200867255532373784442745261542645325315275374222849104412672 binary64)) (+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (+.f64 y (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)))
(if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -1999999999999999977538215750126588953018689196590998459950069697680585223647237336888853938920013796903718410691112844909629852261514762472830507743890852478294863899324781023557461759604328517292041175040 binary64)) (+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 39999999999999998536271862523546296844108572901094271174721455373708346006171549696 binary64)) (+.f64 y x) (+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
(if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -1999999999999999977538215750126588953018689196590998459950069697680585223647237336888853938920013796903718410691112844909629852261514762472830507743890852478294863899324781023557461759604328517292041175040 binary64)) (+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)) (if (<=.f64 (*.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 39999999999999998536271862523546296844108572901094271174721455373708346006171549696 binary64)) (+.f64 x y) (+.f64 x (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))))
(if (<=.f64 b #s(literal -11400000000000000661235347505236286387251546757597094230281391683129777855903301632 binary64)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (if (<=.f64 b #s(literal -7260919251582885/994646472819573284310764496293641680200912301594695434880927953786318994025066751066112 binary64)) (+.f64 x (*.f64 b a)) (if (<=.f64 b #s(literal 139999999999999989346079709825462938729195377918139569274880 binary64)) (+.f64 y x) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(if (<=.f64 b #s(literal -11400000000000000661235347505236286387251546757597094230281391683129777855903301632 binary64)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (if (<=.f64 b #s(literal -7260919251582885/994646472819573284310764496293641680200912301594695434880927953786318994025066751066112 binary64)) (+.f64 x (*.f64 a b)) (if (<=.f64 b #s(literal 139999999999999989346079709825462938729195377918139569274880 binary64)) (+.f64 x y) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(if (<=.f64 b #s(literal -4332790137498831/77371252455336267181195264 binary64)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (if (<=.f64 b #s(literal 115000000000000003991848446516986351976535216231821221036032 binary64)) (+.f64 y x) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(if (<=.f64 b #s(literal -4332790137498831/77371252455336267181195264 binary64)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (if (<=.f64 b #s(literal 115000000000000003991848446516986351976535216231821221036032 binary64)) (+.f64 x y) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(if (<=.f64 a #s(literal -16000000000000000808886843615920541027651792492848052464327703595555724223633366493187734033680995508038673811787218944 binary64)) (*.f64 b a) (if (<=.f64 a #s(literal 420000000000000033380757677273290089352167455508992351255846779441851483170486358146484695282494513417224755996317159248501885136279671869730309707661312 binary64)) (+.f64 y x) (*.f64 b a)))
(if (<=.f64 a #s(literal -16000000000000000808886843615920541027651792492848052464327703595555724223633366493187734033680995508038673811787218944 binary64)) (*.f64 a b) (if (<=.f64 a #s(literal 420000000000000033380757677273290089352167455508992351255846779441851483170486358146484695282494513417224755996317159248501885136279671869730309707661312 binary64)) (+.f64 x y) (*.f64 a b)))
(if (<=.f64 y #s(literal -5692563374268111/6325070415853456823515479584966165845298645305129441198653167438357198111499854590373761990669910140474596183259900372230931523043306046152094168748148078435047419508642698792639590866940413010663742739952273283392562733857021646831815729864036236135650314266011211548510419206725953204130822734645187695728365866909171712 binary64)) x (if (<=.f64 y #s(literal 28999999999999999217874673251247609961461488715019992246745057957393695678398464 binary64)) (*.f64 b a) y))
(if (<=.f64 y #s(literal -5692563374268111/6325070415853456823515479584966165845298645305129441198653167438357198111499854590373761990669910140474596183259900372230931523043306046152094168748148078435047419508642698792639590866940413010663742739952273283392562733857021646831815729864036236135650314266011211548510419206725953204130822734645187695728365866909171712 binary64)) x (if (<=.f64 y #s(literal 28999999999999999217874673251247609961461488715019992246745057957393695678398464 binary64)) (*.f64 a b) y))
(if (<=.f64 y #s(literal 6829486688100709/200867255532373784442745261542645325315275374222849104412672 binary64)) x y)
x

soundness724.0ms (5.7%)

Memory
9.6MiB live, 711.8MiB allocated
Rules
13 462×accelerator-lowering-fma.f32
13 462×accelerator-lowering-fma.f64
5 550×+-lowering-+.f64
5 550×+-lowering-+.f32
5 500×accelerator-lowering-fma.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
089013161
1291612923
0815412266
02022480
16242458
220452392
368462392
081352196
Stop Event
1×fuel
1×iter limit
1×node limit
1×iter limit
1×node limit
Compiler

Compiled 823 to 452 computations (45.1% saved)

preprocess235.0ms (1.8%)

Memory
-15.3MiB live, 234.3MiB allocated
Remove

(sort x y)

Compiler

Compiled 948 to 350 computations (63.1% saved)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...