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

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated

analyze3.0ms (0%)

Memory

8.6MiB live, 8.6MiB allocated

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
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.2s (7.5%)

Memory

53.5MiB live, 1 985.5MiB allocated

Samples

781.0ms	8 253×	0	valid
0.0ms	3×	1	valid

Precisions

Click to see histograms. Total time spent on operations: 480.0ms

ival-add: 150.0ms (31.3% of total)

ival-mult: 129.0ms (26.9% of total)

ival-log: 109.0ms (22.7% of total)

ival-sub: 77.0ms (16% of total)

ival-true: 6.0ms (1.3% of total)

exact: 5.0ms (1% of total)

ival-assert: 3.0ms (0.6% of total)

adjust: 0.0ms (0% of total)

Bogosity

explain154.0ms (1%)

Memory

-17.9MiB live, 307.4MiB allocated

FPErrors

Click to see full error table

Example	Example	Subexpression
-	-	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
-	-	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
-	-	`(log.f64 t)`
-	-	`a`
-	-	`t`
-	-	`z`
-	-	`(+.f64 (+.f64 x y) z)`
-	-	`y`
-	-	`(*.f64 z (log.f64 t))`
-	-	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
-	-	`(+.f64 x y)`
-	-	`b`
-	-	`#s(literal 1/2 binary64)`
-	-	`x`
-	-	`(-.f64 a #s(literal 1/2 binary64))`

Confusion

	Predicted +	Predicted -
+	0	0
-	0	256

Precision

0/0

Recall

0/0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	0	0	0
-	0	0	256

Precision?

0/0

Recall?

0/0

Freqs

test

number	freq
0	256

Total Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	0	0	0
-	0	0	1

Precision?

0/0

Recall?

0/0

Samples

58.0ms

512×

valid

Compiler

Compiled 136 to 49 computations (64% saved)

Precisions

Click to see histograms. Total time spent on operations: 35.0ms

ival-sub: 13.0ms (37.5% of total)

ival-log: 7.0ms (20.2% of total)

ival-add: 7.0ms (20.2% of total)

ival-mult: 7.0ms (20.2% of total)

ival-true: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

preprocess636.0ms (4.1%)

Memory

29.2MiB live, 568.8MiB allocated

Algorithm

1×	egg-herbie

Rules

12 800×	`lower-fma.f64`
12 800×	`lower-fma.f32`
2 968×	`lower-+.f32`
2 968×	`lower--.f32`
2 964×	`lower--.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	125	446
1	415	441
2	1604	434
3	5310	434
4	7907	434
0	15	16
0	23	16
1	42	16
2	109	16
3	324	16
4	899	16
5	2380	16
6	3465	16
7	4942	16
8	5793	16
9	6106	16
10	6205	16
11	6215	16
12	6330	16
13	6634	16
14	6753	16
15	6759	16
16	6759	16
17	6765	16
18	6771	16
19	6771	16
20	6789	16
21	6797	16
22	6797	16
23	7912	16
24	7912	16
0	7912	14

Stop Event

1×	iter limit
1×	saturated
1×	iter limit
1×	node limit

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))

Outputs

(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))

(+.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b y))

Symmetry

(sort x y)

Compiler

Compiled 22 to 15 computations (31.8% saved)

eval0.0ms (0%)

Memory: 0.5MiB live, 0.5MiB allocated
Compiler: Compiled 6 to 6 computations (0% saved)

prune1.0ms (0%)

Memory

1.6MiB live, 1.6MiB allocated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	99.9%	(+.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)

simplify712.0ms (4.6%)

Memory

-64.1MiB live, 531.6MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

New	Metric	Score
cost-diff	0	(+.f64 x y)
cost-diff	0	(+.f64 (+.f64 x y) z)
cost-diff	128	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
cost-diff	128	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Rules

12 800×	`lower-fma.f64`
12 800×	`lower-fma.f32`
2 968×	`lower-+.f32`
2 968×	`lower--.f32`
2 964×	`lower--.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	15	55
0	23	55
1	42	55
2	109	55
3	324	55
4	899	55
5	2380	55
6	3465	55
7	4942	55
8	5793	55
9	6106	55
10	6205	55
11	6215	55
12	6330	55
13	6634	55
14	6753	55
15	6759	55
16	6759	55
17	6765	55
18	6771	55
19	6771	55
20	6789	55
21	6797	55
22	6797	55
23	7912	55
24	7912	55
0	7912	52

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

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))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
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))
(+.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b y))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
(+.f64 a #s(literal -1/2 binary64))
a
#s(literal 1/2 binary64)
b

localize39.0ms (0.2%)

Memory

6.7MiB live, 84.8MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0	(log.f64 t)
accuracy	0.01953125	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
accuracy	0.11328125	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
accuracy	0.25390625	(*.f64 z (log.f64 t))

Samples

26.0ms

256×

valid

Compiler

Compiled 57 to 17 computations (70.2% saved)

Precisions

Click to see histograms. Total time spent on operations: 13.0ms

ival-add: 4.0ms (31.4% of total)

ival-log: 3.0ms (23.5% of total)

ival-mult: 3.0ms (23.5% of total)

ival-sub: 2.0ms (15.7% of total)

ival-true: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

series319.0ms (2.1%)

Memory

14.5MiB live, 533.2MiB allocated

Counts

7 → 240

Calls

Call 1

Inputs
#<alt (+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))>
#<alt (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))>
#<alt (+.f64 (+.f64 x y) z)>
#<alt (+.f64 x y)>
#<alt (*.f64 z (log.f64 t))>
#<alt (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)>
#<alt (log.f64 t)>

Outputs
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<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 (- y (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<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 (- y (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<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>
#<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 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 (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt 1>
#<alt 1>
#<alt 1>
#<alt 1>
#<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:

Time	Variable		Point	Expression
57.0ms	t	@	0	(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
42.0ms	z	@	0	(* z (log t))
40.0ms	z	@	-inf	(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
20.0ms	t	@	inf	(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
13.0ms	t	@	-inf	(- (+ (+ x y) z) (* z (log t)))

simplify344.0ms (2.2%)

Memory

25.2MiB live, 652.9MiB allocated

Algorithm

1×	egg-herbie

Rules

10 038×	`lower-fma.f64`
10 038×	`lower-fma.f32`
7 140×	`lower-+.f64`
7 140×	`lower-+.f32`
5 098×	`lower-*.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	355	2673
1	1051	2646
2	3268	2610
0	8328	2468

Stop Event

1×	iter limit
1×	node limit

Counts

240 → 223

Calls

Call 1

Inputs
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a y) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* 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)))))
(- y (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(* 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))))
(- y (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ 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
(- 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 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)))))
(- a 1/2)
(- a 1/2)
(- a 1/2)
(- a 1/2)
(/ 1 b)
(/ 1 b)
(/ 1 b)
(/ 1 b)
1
1
1
1
(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 (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 x (+.f64 a (+.f64 z #s(literal -1/2 binary64))))) (log.f64 (+.f64 a (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 x (fma.f64 #s(literal 1/2 binary64) (/.f64 x (*.f64 (+.f64 a (+.f64 z #s(literal -1/2 binary64))) (+.f64 a (+.f64 z #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 a (+.f64 z #s(literal -1/2 binary64))))) y)) (log.f64 (+.f64 a (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 a (+.f64 z #s(literal -1/2 binary64))) (.f64 (+.f64 a (+.f64 z #s(literal -1/2 binary64))) (+.f64 a (+.f64 z #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 a (+.f64 z #s(literal -1/2 binary64))) (+.f64 a (+.f64 z #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 a (+.f64 z #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 a (+.f64 z #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(+.f64 (-.f64 (-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (.f64 x (.f64 x x)) (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))) (/.f64 #s(literal -1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ a z) (+ 1/2 (* t z)))
(-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64)))
(- (+ a z) (+ 1/2 (* t z)))
(-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64)))
(- (+ a z) (+ 1/2 (* t z)))
(-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64)))
(- (+ a z) (+ 1/2 (* t z)))
(-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64))))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64))))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64))))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64))))))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (-.f64 (/.f64 #s(literal -1 binary64) (*.f64 y (+.f64 a (+.f64 x #s(literal -1/2 binary64))))) (log.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64)))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 (+.f64 (-.f64 (/.f64 #s(literal -1 binary64) (.f64 y (+.f64 a (+.f64 x #s(literal -1/2 binary64))))) (log.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/2 binary64) (.f64 y (.f64 y (.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (+.f64 a (+.f64 x #s(literal -1/2 binary64)))))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 (+.f64 (+.f64 (-.f64 (/.f64 #s(literal -1 binary64) (.f64 y (+.f64 a (+.f64 x #s(literal -1/2 binary64))))) (log.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/2 binary64) (.f64 y (.f64 y (.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (+.f64 a (+.f64 x #s(literal -1/2 binary64)))))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)) (/.f64 #s(literal -1/3 binary64) (.f64 (.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (+.f64 a (+.f64 x #s(literal -1/2 binary64)))) (.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (.f64 y (*.f64 y y))))))
(- (+ a z) (+ 1/2 (* t z)))
(-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64)))
(- (+ a z) (+ 1/2 (* t z)))
(-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64)))
(- (+ a z) (+ 1/2 (* t z)))
(-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64)))
(- (+ a z) (+ 1/2 (* t z)))
(-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 z (+.f64 a (+.f64 x #s(literal -1/2 binary64))))) (log.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 #s(literal 1/2 binary64) (/.f64 z (*.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (+.f64 a (+.f64 x #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 a (+.f64 x #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (+.f64 a (+.f64 x #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (+.f64 a (+.f64 x #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 a (+.f64 x #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (*.f64 z (+.f64 a (+.f64 x #s(literal -1/2 binary64))))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 y (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (.f64 z z))))) (-.f64 (/.f64 #s(literal -1 binary64) (.f64 z (+.f64 a (+.f64 x #s(literal -1/2 binary64))))) (log.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64)))))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 y (+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (.f64 z z))))) (log.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))))) (+.f64 (/.f64 #s(literal -1 binary64) (.f64 z (+.f64 a (+.f64 x #s(literal -1/2 binary64))))) (/.f64 #s(literal -1/3 binary64) (.f64 (.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (+.f64 a (+.f64 x #s(literal -1/2 binary64)))) (.f64 (+.f64 a (+.f64 x #s(literal -1/2 binary64))) (.f64 z (*.f64 z z))))))))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a #s(literal -1/2 binary64)) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (/.f64 b (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a #s(literal -1/2 binary64)) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (/.f64 b (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a #s(literal -1/2 binary64)) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (/.f64 b (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64))))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64))))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64))))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64))))))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 b #s(literal -1/2 binary64) y) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (fma.f64 #s(literal -1/3 binary64) (/.f64 a (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(*.f64 a (-.f64 (+.f64 b (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a))) (/.f64 (log.f64 a) a)))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (+.f64 b (-.f64 (+.f64 (/.f64 y a) (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 #s(literal 1/2 binary64) (.f64 a a)))) (+.f64 (/.f64 (log.f64 a) a) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (.f64 a a)))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (-.f64 (+.f64 (+.f64 b (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a))) (+.f64 (/.f64 #s(literal 1/2 binary64) (.f64 a a)) (/.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (+.f64 z x) #s(literal -1/4 binary64)) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))) (.f64 a (.f64 a a))))) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (*.f64 a a)))) (/.f64 (log.f64 a) 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 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) (fma.f64 b #s(literal -1/2 binary64) x)) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) (fma.f64 b #s(literal -1/2 binary64) x)) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) (fma.f64 b #s(literal -1/2 binary64) x)) a)))
(- y (log (- (+ a (+ x z)) 1/2)))
(-.f64 y (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64))))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64))))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64))))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64))))))
(* 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 (fma.f64 (log.f64 t) (/.f64 z b) #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 (fma.f64 (log.f64 t) (/.f64 z b) #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 (fma.f64 (log.f64 t) (/.f64 z b) #s(literal 1/2 binary64)))))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- (+ y z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
x
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(fma.f64 x (-.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (/.f64 (*.f64 z (log.f64 t)) x)) x)
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(fma.f64 x (-.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (/.f64 (*.f64 z (log.f64 t)) x)) x)
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(fma.f64 x (-.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (/.f64 (*.f64 z (log.f64 t)) x)) x)
x
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 x (neg.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x))))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 x (neg.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x))))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 x (neg.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x))))
(- (+ x z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
y
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(fma.f64 y (-.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (/.f64 (*.f64 z (log.f64 t)) y)) y)
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(fma.f64 y (-.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (/.f64 (*.f64 z (log.f64 t)) y)) y)
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(fma.f64 y (-.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (/.f64 (*.f64 z (log.f64 t)) y)) y)
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(neg.f64 (*.f64 y (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y))))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(neg.f64 (*.f64 y (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y))))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(neg.f64 (*.f64 y (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y))))
(+ x y)
(+.f64 y x)
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(+ x (+ y (* z (- 1 (log t)))))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(* z (- 1 (log t)))
(-.f64 z (*.f64 z (log.f64 t)))
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(fma.f64 z (+.f64 (/.f64 x z) (-.f64 (/.f64 y z) (log.f64 t))) z)
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(fma.f64 z (+.f64 (/.f64 x z) (-.f64 (/.f64 y z) (log.f64 t))) z)
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(fma.f64 z (+.f64 (/.f64 x z) (-.f64 (/.f64 y z) (log.f64 t))) z)
(* z (+ 1 (* -1 (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (/.f64 (+.f64 y x) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (/.f64 (+.f64 y x) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (/.f64 (+.f64 y x) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(- (+ x (+ y z)) (* z (log t)))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(+.f64 y (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(-.f64 (+.f64 y (+.f64 z x)) (*.f64 z (-.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 (+.f64 y (+.f64 z x)) (*.f64 z (-.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 (+.f64 y (+.f64 z x)) (*.f64 z (-.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 (+.f64 y (+.f64 z x)) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))))
(+ y z)
(+.f64 y z)
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
x
(* x (+ 1 (+ (/ y x) (/ z x))))
(fma.f64 x (+.f64 (/.f64 y x) (/.f64 z x)) x)
(* x (+ 1 (+ (/ y x) (/ z x))))
(fma.f64 x (+.f64 (/.f64 y x) (/.f64 z x)) x)
(* x (+ 1 (+ (/ y x) (/ z x))))
(fma.f64 x (+.f64 (/.f64 y x) (/.f64 z x)) x)
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 y z) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 y z) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 y z) x)) (neg.f64 x))
(+ x z)
(+.f64 z x)
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
y
(* y (+ 1 (+ (/ x y) (/ z y))))
(fma.f64 y (+.f64 (/.f64 x y) (/.f64 z y)) y)
(* y (+ 1 (+ (/ x y) (/ z y))))
(fma.f64 y (+.f64 (/.f64 x y) (/.f64 z y)) y)
(* y (+ 1 (+ (/ x y) (/ z y))))
(fma.f64 y (+.f64 (/.f64 x y) (/.f64 z y)) y)
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z x) y)) (neg.f64 y))
(+ x y)
(+.f64 y x)
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(fma.f64 z (+.f64 (/.f64 x z) (/.f64 y z)) z)
(* z (+ 1 (+ (/ x z) (/ y z))))
(fma.f64 z (+.f64 (/.f64 x z) (/.f64 y z)) z)
(* z (+ 1 (+ (/ x z) (/ y z))))
(fma.f64 z (+.f64 (/.f64 x z) (/.f64 y z)) z)
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(fma.f64 (neg.f64 (/.f64 (+.f64 y x) z)) (neg.f64 z) z)
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(fma.f64 (neg.f64 (/.f64 (+.f64 y x) z)) (neg.f64 z) z)
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(fma.f64 (neg.f64 (/.f64 (+.f64 y x) z)) (neg.f64 z) z)
y
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
x
(* x (+ 1 (/ y x)))
(fma.f64 x (/.f64 y x) x)
(* x (+ 1 (/ y x)))
(fma.f64 x (/.f64 y x) x)
(* x (+ 1 (/ y x)))
(fma.f64 x (/.f64 y x) x)
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 y x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 y x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 y x)) (neg.f64 x))
x
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
y
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 x y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 x y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 x y)) (neg.f64 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
#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))))
(fma.f64 a (/.f64 #s(literal -1/2 binary64) a) a)
(* a (- 1 (* 1/2 (/ 1 a))))
(fma.f64 a (/.f64 #s(literal -1/2 binary64) a) a)
(* a (- 1 (* 1/2 (/ 1 a))))
(fma.f64 a (/.f64 #s(literal -1/2 binary64) a) a)
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 b a) (neg.f64 b)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 b a) (neg.f64 b)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 b a) (neg.f64 b)) (neg.f64 a))
(- 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 1/2)
(+.f64 a #s(literal -1/2 binary64))
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 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)))

rewrite391.0ms (2.5%)

Memory

-23.1MiB live, 689.7MiB allocated

Rules

7 722×	`lower-fma.f64`
7 722×	`lower-fma.f32`
4 336×	`lower-*.f32`
4 332×	`lower-*.f64`
3 996×	`lower-/.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	15	45
0	23	45
1	105	45
2	948	45
0	8252	44

Stop Event

1×	iter limit
1×	node limit
1×	iter limit

Counts

7 → 432

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))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
(*.f64 z (log.f64 t))
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(log.f64 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)) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 (+.f64 x (+.f64 y z)) (fma.f64 (log.f64 t) (neg.f64 z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(+.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(+.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))
(+.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (neg.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 z (log.f64 t))))
(+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 y z))) (*.f64 (log.f64 t) (neg.f64 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 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(-.f64 (fma.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)))) (fma.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)) (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))) (/.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
(-.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 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x y) (+.f64 x y) (.f64 z (-.f64 z (+.f64 x y))))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x y) (+.f64 x y) (.f64 z (-.f64 z (+.f64 x y))))) (fma.f64 (log.f64 t) (neg.f64 z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z z (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (.f64 (+.f64 x y) z)))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z z (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (.f64 (+.f64 x y) z)))) (fma.f64 (log.f64 t) (neg.f64 z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (neg.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (.f64 x x))) (+.f64 (-.f64 z (.f64 z (log.f64 t))) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (.f64 x x))) (-.f64 z (-.f64 (.f64 z (log.f64 t)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.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 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.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 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.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) (neg.f64 z)))))) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))) (fma.f64 (log.f64 t) (neg.f64 z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x 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 y) (-.f64 x 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) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.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)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x)))) (+.f64 (-.f64 z (.f64 z (log.f64 t))) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x)))) (-.f64 z (-.f64 (.f64 z (log.f64 t)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (neg.f64 (.f64 (+.f64 x y) (-.f64 x y))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 x y))) (+.f64 (-.f64 z (.f64 z (log.f64 t))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (neg.f64 (.f64 (+.f64 x y) (-.f64 x y))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 x y))) (-.f64 z (-.f64 (.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (neg.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (+.f64 x y) (+.f64 x y) (.f64 z (-.f64 z (+.f64 x y)))))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (neg.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (+.f64 x y) (+.f64 x y) (.f64 z (-.f64 z (+.f64 x y)))))) (fma.f64 (log.f64 t) (neg.f64 z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (neg.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (+.f64 x (-.f64 y z)))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (neg.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (+.f64 x (-.f64 y z)))) (fma.f64 (log.f64 t) (neg.f64 z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (fma.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) (fma.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 (fma.f64 x (.f64 x x) (.f64 (+.f64 y z) (.f64 (+.f64 y z) (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (-.f64 (.f64 (+.f64 y z) (+.f64 y z)) (.f64 x (+.f64 y z))))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 y z) (.f64 (+.f64 y z) (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (-.f64 (.f64 (+.f64 y z) (+.f64 y z)) (.f64 x (+.f64 y z))))) (fma.f64 (log.f64 t) (neg.f64 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)) (neg.f64 (-.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)) (fma.f64 (log.f64 t) (neg.f64 z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) (*.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 x y) (-.f64 y 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 x y) (-.f64 y 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 (+.f64 y z)) (-.f64 x (+.f64 y z))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 y z))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (.f64 (+.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 y z))) (fma.f64 (log.f64 t) (neg.f64 z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (.f64 (+.f64 x (+.f64 y z)) (-.f64 z (+.f64 x y))) (/.f64 #s(literal 1 binary64) (-.f64 z (+.f64 x y))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (.f64 (+.f64 x (+.f64 y z)) (-.f64 z (+.f64 x y))) (/.f64 #s(literal 1 binary64) (-.f64 z (+.f64 x y))) (fma.f64 (log.f64 t) (neg.f64 z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))
(fma.f64 (*.f64 b (fma.f64 a a #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))
(fma.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b) (/.f64 #s(literal 1 binary64) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))
(fma.f64 (*.f64 (fma.f64 a a #s(literal -1/4 binary64)) b) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))
(/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 3 binary64))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64))))
(/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 3 binary64))) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (neg.f64 (-.f64 (+.f64 x (+.f64 y z)) (fma.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))) (fma.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) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.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) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #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) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))))))
(/.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))))
(/.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 (fma.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))))) (.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (+.f64 a #s(literal 1/2 binary64)) (.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (.f64 b (fma.f64 a a #s(literal -1/4 binary64))))) (.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (fma.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b))) (.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (+.f64 a #s(literal 1/2 binary64)) (.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b))) (.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (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))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))))) (.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (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 a #s(literal 1/2 binary64)) (.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) (.f64 b (fma.f64 a a #s(literal -1/4 binary64))))) (*.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (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))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b))) (.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (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 a #s(literal 1/2 binary64)) (.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b))) (*.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (fma.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64)))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))))) (.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64)))) (+.f64 a #s(literal 1/2 binary64)) (.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (.f64 b (fma.f64 a a #s(literal -1/4 binary64))))) (.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (fma.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64)))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b))) (.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64)))) (+.f64 a #s(literal 1/2 binary64)) (.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b))) (.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (fma.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)))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))))) (.f64 (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.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)))) (+.f64 a #s(literal 1/2 binary64)) (.f64 (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (.f64 b (fma.f64 a a #s(literal -1/4 binary64))))) (*.f64 (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (fma.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)))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b))) (.f64 (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.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)))) (+.f64 a #s(literal 1/2 binary64)) (.f64 (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b))) (*.f64 (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (.f64 z (log.f64 t))) #s(literal 3 binary64))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (fma.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 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))))) (.f64 (fma.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)))))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.f64 (fma.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 (fma.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 (fma.f64 a a #s(literal -1/4 binary64))))) (.f64 (fma.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 (fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (.f64 z (log.f64 t))) #s(literal 3 binary64))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (fma.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 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b))) (.f64 (fma.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)))))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.f64 (fma.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 (fma.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 (fma.f64 a a #s(literal -1/4 binary64)) b))) (.f64 (fma.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 (fma.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (fma.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) (neg.f64 z))))) (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))))) (.f64 (fma.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) (neg.f64 z))))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (+.f64 a #s(literal 1/2 binary64)) (.f64 (fma.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) (neg.f64 z))))) (.f64 b (fma.f64 a a #s(literal -1/4 binary64))))) (.f64 (fma.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) (neg.f64 z))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (fma.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (fma.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) (neg.f64 z))))) (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b))) (.f64 (fma.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) (neg.f64 z))))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (+.f64 a #s(literal 1/2 binary64)) (.f64 (fma.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) (neg.f64 z))))) (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b))) (.f64 (fma.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) (neg.f64 z))))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (fma.f64 #s(literal 1 binary64) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))))) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (.f64 b (fma.f64 a a #s(literal -1/4 binary64))))) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (fma.f64 #s(literal 1 binary64) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b))) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64)) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b))) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (fma.f64 (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (.f64 z (log.f64 t))) #s(literal 2 binary64))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (-.f64 (+.f64 x y) (-.f64 z (.f64 z (log.f64 t)))) (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))))) (.f64 (-.f64 (+.f64 x y) (-.f64 z (.f64 z (log.f64 t)))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.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 (fma.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 (fma.f64 (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (.f64 z (log.f64 t))) #s(literal 2 binary64))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (-.f64 (+.f64 x y) (-.f64 z (.f64 z (log.f64 t)))) (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b))) (.f64 (-.f64 (+.f64 x y) (-.f64 z (.f64 z (log.f64 t)))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (fma.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 (fma.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 (fma.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))))
(/.f64 (fma.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 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 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))
(/.f64 (fma.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64)))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))))
(/.f64 (fma.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (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)))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))
(/.f64 (fma.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) (fma.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 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.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 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.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 (fma.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) (fma.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) (neg.f64 z))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.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) (neg.f64 z)))))))
(/.f64 (fma.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) #s(literal 1 binary64))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
(/.f64 (fma.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) (-.f64 (+.f64 x y) (-.f64 z (.f64 z (log.f64 t)))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (.f64 z (log.f64 t))) #s(literal 2 binary64))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (-.f64 (+.f64 x y) (-.f64 z (.f64 z (log.f64 t))))))
(/.f64 (fma.f64 (.f64 b (fma.f64 a a #s(literal -1/4 binary64))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))))
(/.f64 (fma.f64 (.f64 b (fma.f64 a a #s(literal -1/4 binary64))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) (.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)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))
(/.f64 (fma.f64 (.f64 b (fma.f64 a a #s(literal -1/4 binary64))) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64)))))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))))
(/.f64 (fma.f64 (.f64 b (fma.f64 a a #s(literal -1/4 binary64))) (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (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)))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))
(/.f64 (fma.f64 (.f64 b (fma.f64 a a #s(literal -1/4 binary64))) (fma.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)) (fma.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)) (fma.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 (fma.f64 (.f64 b (fma.f64 a a #s(literal -1/4 binary64))) (fma.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) (neg.f64 z))))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (fma.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) (neg.f64 z)))))))
(/.f64 (fma.f64 (.f64 b (fma.f64 a a #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (.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) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
(/.f64 (fma.f64 (.f64 b (fma.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 (fma.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))))
(/.f64 (fma.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 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 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))
(/.f64 (fma.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64)))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))))
(/.f64 (fma.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b) (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (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)))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))
(/.f64 (fma.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b) (fma.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 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.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 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.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 (fma.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b) (fma.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) (neg.f64 z))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.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) (neg.f64 z)))))))
(/.f64 (fma.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) #s(literal 1 binary64))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
(/.f64 (fma.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b) (-.f64 (+.f64 x y) (-.f64 z (.f64 z (log.f64 t)))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (.f64 z (log.f64 t))) #s(literal 2 binary64))))) (.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (-.f64 (+.f64 x y) (-.f64 z (.f64 z (log.f64 t))))))
(/.f64 (fma.f64 (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))))
(/.f64 (fma.f64 (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) (.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)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))
(/.f64 (fma.f64 (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64)))))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))))
(/.f64 (fma.f64 (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b) (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (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)))))) (*.f64 (+.f64 a #s(literal 1/2 binary64)) (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))
(/.f64 (fma.f64 (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b) (fma.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)) (fma.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)) (fma.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 (fma.f64 (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b) (fma.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) (neg.f64 z))))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))))) (.f64 (+.f64 a #s(literal 1/2 binary64)) (fma.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) (neg.f64 z)))))))
(/.f64 (fma.f64 (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (.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) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
(/.f64 (fma.f64 (.f64 (fma.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 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))) (.f64 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (.f64 (fma.f64 (+.f64 x y) (+.f64 x y) (.f64 z (-.f64 z (+.f64 x y)))) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (.f64 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))) (.f64 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (.f64 (fma.f64 z z (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (.f64 (+.f64 x y) z))) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 y z)) (+.f64 x (-.f64 y z))) (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (.f64 (+.f64 x (-.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (.f64 (neg.f64 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 (neg.f64 (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))) (.f64 (neg.f64 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 (neg.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 (neg.f64 (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (.f64 (neg.f64 (fma.f64 (+.f64 x y) (+.f64 x y) (.f64 z (-.f64 z (+.f64 x y))))) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (.f64 (neg.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z)))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 (neg.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))) (.f64 (neg.f64 (+.f64 x (-.f64 y z))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 (neg.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z)))) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 (neg.f64 (+.f64 x (-.f64 y z))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (.f64 (neg.f64 (+.f64 x (-.f64 y z))) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (.f64 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))) (.f64 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 (fma.f64 x (.f64 x x) (.f64 (+.f64 y z) (.f64 (+.f64 y z) (+.f64 y z)))) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (.f64 (fma.f64 x x (-.f64 (.f64 (+.f64 y z) (+.f64 y z)) (.f64 x (+.f64 y z)))) (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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) (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))) (fma.f64 z (log.f64 t) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 y z)) (-.f64 x (+.f64 y z))) (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (.f64 (-.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (.f64 (.f64 (+.f64 x (+.f64 y z)) (-.f64 z (+.f64 x y))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 y z)) (-.f64 z (+.f64 x y))) (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (.f64 (-.f64 z (+.f64 x y)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (.f64 (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (.f64 (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (neg.f64 (neg.f64 (-.f64 (+.f64 x (+.f64 y z)) (fma.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 (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
(/.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 (fma.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))) (fma.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 (fma.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))) (fma.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 (fma.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))) (fma.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 (fma.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))) (fma.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 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (neg.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) #s(literal 3 binary64))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (-.f64 (.f64 (neg.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (.f64 (+.f64 x (+.f64 y z)) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (-.f64 (.f64 (fma.f64 (log.f64 t) (neg.f64 z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (fma.f64 (log.f64 t) (neg.f64 z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 (+.f64 x (+.f64 y z)) (fma.f64 (log.f64 t) (neg.f64 z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (+.f64 (pow.f64 (fma.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))) (fma.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (fma.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 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 z (log.f64 t)))))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 y z))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (fma.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 y z))) (fma.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 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 y z))) (.f64 (log.f64 t) (neg.f64 z))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 3 binary64)) (pow.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (fma.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))))
(/.f64 (-.f64 (pow.f64 (fma.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))) (fma.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 y z))) (fma.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 (fma.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 (neg.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (-.f64 (+.f64 x (+.f64 y z)) (neg.f64 (-.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 (fma.f64 (log.f64 t) (neg.f64 z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (fma.f64 (log.f64 t) (neg.f64 z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 (log.f64 t) (neg.f64 z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (fma.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 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (-.f64 (.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 y z))) (fma.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 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 y z))) (*.f64 (log.f64 t) (neg.f64 z))))
(/.f64 (-.f64 (.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 y z))) (fma.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 (fma.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 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (+.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))) #s(literal -1 binary64))
(.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)))))
(.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64))))))
(.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (+.f64 x (+.f64 y z)) (fma.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) (fma.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) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))))
(.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
(.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) (neg.f64 z)))
(+.f64 (*.f64 (log.f64 t) (neg.f64 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)))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (neg.f64 (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))))
(+.f64 (/.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (neg.f64 (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))
(-.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)))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))))
(-.f64 (/.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))
(-.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 (neg.f64 (log.f64 t)) (+.f64 x (+.f64 y z)))
(fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x y) (+.f64 x y) (.f64 z (-.f64 z (+.f64 x y))))) (*.f64 (log.f64 t) (neg.f64 z)))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z z (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (.f64 (+.f64 x y) z)))) (.f64 (log.f64 t) (neg.f64 z)))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (.f64 x x))) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.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) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (neg.f64 (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))))
(fma.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (neg.f64 (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))
(fma.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))) (.f64 (log.f64 t) (neg.f64 z)))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (-.f64 z (.f64 z (log.f64 t))))
(fma.f64 (neg.f64 z) (log.f64 t) (+.f64 x (+.f64 y z)))
(fma.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x)))) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (neg.f64 (.f64 (+.f64 x y) (-.f64 x y))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 x y))) (-.f64 z (.f64 z (log.f64 t))))
(fma.f64 (neg.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (+.f64 x y) (+.f64 x y) (.f64 z (-.f64 z (+.f64 x y)))))) (*.f64 (log.f64 t) (neg.f64 z)))
(fma.f64 (neg.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (+.f64 x (-.f64 y z)))) (.f64 (log.f64 t) (neg.f64 z)))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 y z) (.f64 (+.f64 y z) (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (-.f64 (.f64 (+.f64 y z) (+.f64 y z)) (.f64 x (+.f64 y z))))) (.f64 (log.f64 t) (neg.f64 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) (fma.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) (neg.f64 z)))
(fma.f64 #s(literal -1 binary64) (*.f64 z (log.f64 t)) (+.f64 x (+.f64 y z)))
(fma.f64 (.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) (-.f64 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 y z))) (.f64 (log.f64 t) (neg.f64 z)))
(fma.f64 (.f64 (+.f64 x (+.f64 y z)) (-.f64 z (+.f64 x y))) (/.f64 #s(literal 1 binary64) (-.f64 z (+.f64 x y))) (.f64 (log.f64 t) (neg.f64 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 (neg.f64 (log.f64 t)) z (+.f64 x (+.f64 y z)))
(/.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))
(/.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (fma.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) (neg.f64 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))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))
(/.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))))
(/.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64)))) (neg.f64 (fma.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) (neg.f64 z)))))))
(/.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 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))
(/.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (.f64 z (log.f64 t))) #s(literal 3 binary64))) (fma.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) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.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)))))) (fma.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 (fma.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) (neg.f64 z))))) (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (*.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) #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) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
(/.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 (fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t))))) (.f64 (fma.f64 y (-.f64 y x) (.f64 x x)) (-.f64 (.f64 z (.f64 z z)) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))))) (.f64 (fma.f64 y (-.f64 y x) (.f64 x x)) (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t)))))))
(/.f64 (fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (+.f64 z (.f64 z (log.f64 t))) (.f64 (fma.f64 y (-.f64 y x) (.f64 x x)) (-.f64 (.f64 z z) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))))) (.f64 (fma.f64 y (-.f64 y x) (.f64 x x)) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t))))) (.f64 (fma.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 (fma.f64 y y (-.f64 (.f64 x x) (.f64 x y))) (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t)))))))
(/.f64 (fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (+.f64 z (.f64 z (log.f64 t))) (.f64 (fma.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 (fma.f64 y y (-.f64 (.f64 x x) (.f64 x y))) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (fma.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) (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t)))))))
(/.f64 (fma.f64 (.f64 (+.f64 x y) (-.f64 x 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 (fma.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (fma.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 (fma.f64 y (-.f64 y x) (.f64 x x))) (-.f64 (.f64 z (.f64 z z)) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))))) (.f64 (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x))) (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t)))))))
(/.f64 (fma.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (+.f64 z (.f64 z (log.f64 t))) (.f64 (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x))) (-.f64 (.f64 z z) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))))) (.f64 (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x))) (+.f64 z (*.f64 z (log.f64 t)))))
(/.f64 (fma.f64 (neg.f64 (.f64 (+.f64 x y) (-.f64 x y))) (fma.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)) (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t)))))))
(/.f64 (fma.f64 (neg.f64 (.f64 (+.f64 x y) (-.f64 x 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 (fma.f64 #s(literal 1 binary64) (fma.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)) (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (*.f64 z (log.f64 t)))))))
(/.f64 (fma.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 (fma.f64 (.f64 (+.f64 x y) (-.f64 y x)) (fma.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) (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t)))))))
(/.f64 (fma.f64 (.f64 (+.f64 x y) (-.f64 y 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 (fma.f64 (-.f64 (.f64 z (.f64 z z)) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (fma.f64 y (-.f64 y x) (.f64 x x)) (.f64 (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t))))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))) (.f64 (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t))))) (fma.f64 y (-.f64 y x) (.f64 x x))))
(/.f64 (fma.f64 (-.f64 (.f64 z (.f64 z z)) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (.f64 x x) (.f64 x y))) (.f64 (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t))))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))) (.f64 (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t))))) (fma.f64 y y (-.f64 (.f64 x x) (.f64 x y)))))
(/.f64 (fma.f64 (-.f64 (.f64 z (.f64 z z)) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (-.f64 x y) (.f64 (fma.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 x y)))) (.f64 (fma.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 (fma.f64 (-.f64 (.f64 z (.f64 z z)) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x))) (.f64 (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t))))) (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))) (.f64 (fma.f64 z z (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z (.f64 z (log.f64 t))))) (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x)))))
(/.f64 (fma.f64 (-.f64 (.f64 z (.f64 z z)) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (neg.f64 (-.f64 x y)) (.f64 (fma.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 y) (-.f64 x y))))) (.f64 (fma.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 (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 x y)) (.f64 (fma.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 (fma.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 (fma.f64 (-.f64 (.f64 z (.f64 z z)) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (-.f64 y x) (.f64 (fma.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 y x)))) (.f64 (fma.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 (fma.f64 (-.f64 (.f64 z z) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (fma.f64 y (-.f64 y x) (.f64 x x)) (.f64 (+.f64 z (.f64 z (log.f64 t))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))) (.f64 (+.f64 z (.f64 z (log.f64 t))) (fma.f64 y (-.f64 y x) (*.f64 x x))))
(/.f64 (fma.f64 (-.f64 (.f64 z z) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (fma.f64 y y (-.f64 (.f64 x x) (.f64 x y))) (.f64 (+.f64 z (.f64 z (log.f64 t))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))) (.f64 (+.f64 z (.f64 z (log.f64 t))) (fma.f64 y y (-.f64 (.f64 x x) (*.f64 x y)))))
(/.f64 (fma.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 y) (-.f64 x y)))) (.f64 (+.f64 z (*.f64 z (log.f64 t))) (-.f64 x y)))
(/.f64 (fma.f64 (-.f64 (.f64 z z) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x))) (.f64 (+.f64 z (.f64 z (log.f64 t))) (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))) (.f64 (+.f64 z (.f64 z (log.f64 t))) (neg.f64 (fma.f64 y (-.f64 y x) (*.f64 x x)))))
(/.f64 (fma.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 y) (-.f64 x y))))) (.f64 (+.f64 z (*.f64 z (log.f64 t))) (neg.f64 (-.f64 x y))))
(/.f64 (fma.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 (fma.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 x y) (-.f64 y 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)))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)))) (pow.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) #s(literal 2 binary64)))
(/.f64 (-.f64 (.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)))) (pow.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))))
(/.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 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))
(/.f64 (neg.f64 (fma.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 (fma.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 (fma.f64 x (.f64 x x) (pow.f64 (+.f64 y (-.f64 z (.f64 z (log.f64 t)))) #s(literal 3 binary64))) (fma.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 (fma.f64 x (.f64 x x) (pow.f64 (-.f64 (+.f64 y z) (.f64 z (log.f64 t))) #s(literal 3 binary64))) (fma.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 (fma.f64 y (.f64 y y) (pow.f64 (+.f64 x (-.f64 z (.f64 z (log.f64 t)))) #s(literal 3 binary64))) (fma.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 (fma.f64 z (.f64 z z) (pow.f64 (-.f64 (+.f64 x y) (.f64 z (log.f64 t))) #s(literal 3 binary64))) (fma.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) (neg.f64 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) (neg.f64 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)))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) #s(literal 3 binary64)) (pow.f64 (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (/.f64 (.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (fma.f64 (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (.f64 (/.f64 (.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) #s(literal 3 binary64)) (pow.f64 (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (/.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (fma.f64 (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (.f64 (/.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (/.f64 (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))))
(/.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) (neg.f64 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)))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (/.f64 (.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))) (.f64 (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))))) (+.f64 (/.f64 (.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)))) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (/.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))) (.f64 (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))) (+.f64 (/.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))) #s(literal -1 binary64))
(.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))))
(.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.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) (neg.f64 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) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))))
(.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z))) (pow.f64 (.f64 (log.f64 t) (neg.f64 z)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (+.f64 x (+.f64 y z)) (+.f64 x (+.f64 y z)) (.f64 (*.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))))
(.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)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z))))))
(.f64 (fma.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) (fma.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) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))
(.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 x (-.f64 y z))) (neg.f64 (/.f64 (.f64 z z) (+.f64 x (-.f64 y z)))))
(+.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))))
(-.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 x (-.f64 y z))) (neg.f64 (/.f64 (.f64 z z) (+.f64 x (-.f64 y z)))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (.f64 x x))) z)
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y y (-.f64 (.f64 x x) (*.f64 x y)))) z)
(fma.f64 (*.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) z)
(fma.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x)))) z)
(fma.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 x y))) z)
(fma.f64 (fma.f64 y (.f64 y y) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.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 z) (-.f64 y z)) (/.f64 #s(literal 1 binary64) (-.f64 y z)) x)
(fma.f64 (*.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) z)
(/.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (fma.f64 (+.f64 x y) (+.f64 x y) (.f64 z (-.f64 z (+.f64 x y)))))
(/.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (fma.f64 z z (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))))
(/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z))) (+.f64 x (-.f64 y z)))
(/.f64 (neg.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (neg.f64 (fma.f64 (+.f64 x y) (+.f64 x y) (.f64 z (-.f64 z (+.f64 x y))))))
(/.f64 (neg.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (neg.f64 (fma.f64 z z (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z)))))
(/.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z)))) (neg.f64 (+.f64 x (-.f64 y z))))
(/.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 y z) (.f64 (+.f64 y z) (+.f64 y z)))) (fma.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 (fma.f64 z z (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (.f64 (+.f64 x y) z))) (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x x (-.f64 (.f64 (+.f64 y z) (+.f64 y z)) (.f64 x (+.f64 y z)))) (fma.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 (+.f64 y z)) (-.f64 x (+.f64 y z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (+.f64 x y)) (*.f64 (+.f64 x (+.f64 y z)) (-.f64 z (+.f64 x y)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z)))))
(/.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z))) (-.f64 x (+.f64 y z)))
(/.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 z (+.f64 x y))) (-.f64 z (+.f64 x y)))
(/.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 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))))) (neg.f64 (neg.f64 (fma.f64 (+.f64 x y) (+.f64 x y) (.f64 z (-.f64 z (+.f64 x y)))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z))))) (neg.f64 (neg.f64 (+.f64 x (-.f64 y z)))))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 y z) (.f64 (+.f64 y z) (+.f64 y z))))) (neg.f64 (fma.f64 x x (-.f64 (.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z))))))
(/.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z)))) (neg.f64 (-.f64 x (+.f64 y z))))
(/.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 z (+.f64 x y)))) (neg.f64 (-.f64 z (+.f64 x y))))
(/.f64 (fma.f64 y (.f64 y y) (pow.f64 (+.f64 x z) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (.f64 (+.f64 x z) (+.f64 x z)) (*.f64 y (+.f64 x z)))))
(/.f64 (fma.f64 (+.f64 y z) (.f64 (+.f64 y z) (+.f64 y z)) (.f64 x (.f64 x x))) (fma.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))) (fma.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 x (-.f64 y z))) #s(literal 3 binary64)) (pow.f64 (/.f64 (.f64 z z) (+.f64 x (-.f64 y z))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (/.f64 (.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (fma.f64 (/.f64 (.f64 z z) (+.f64 x (-.f64 y z))) (/.f64 (.f64 z z) (+.f64 x (-.f64 y z))) (.f64 (/.f64 (.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (/.f64 (*.f64 z z) (+.f64 x (-.f64 y 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 x (-.f64 y z))) (/.f64 (.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z)))) (.f64 (/.f64 (.f64 z z) (+.f64 x (-.f64 y z))) (/.f64 (.f64 z z) (+.f64 x (-.f64 y z))))) (+.f64 (/.f64 (.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (/.f64 (.f64 z z) (+.f64 x (-.f64 y z)))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))) #s(literal -1 binary64))
(.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x y) (+.f64 x y) (*.f64 z (-.f64 z (+.f64 x y))))))
(.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z z (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (.f64 (+.f64 x y) z)))))
(.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))))
(.f64 (neg.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (+.f64 x y) (+.f64 x y) (*.f64 z (-.f64 z (+.f64 x y)))))))
(.f64 (neg.f64 (.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (+.f64 x (-.f64 y z)))))
(.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 y z) (.f64 (+.f64 y z) (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (fma.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 (+.f64 y z)) (-.f64 x (+.f64 y z))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 y z))))
(.f64 (.f64 (+.f64 x (+.f64 y z)) (-.f64 z (+.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 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 y (-.f64 y x) (.f64 x x)))
(/.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 y y (-.f64 (.f64 x x) (*.f64 x y))))
(/.f64 (*.f64 (+.f64 x y) (-.f64 x y)) (-.f64 x y))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x))))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 y y (-.f64 (.f64 x x) (*.f64 x y)))))
(/.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y))) (neg.f64 (-.f64 x y)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 x y)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 y y (-.f64 (.f64 x x) (.f64 x y))) (fma.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 x y) (-.f64 y x))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y))))
(/.f64 (*.f64 (+.f64 x y) (-.f64 y 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 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))) (neg.f64 (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y)))) (neg.f64 (neg.f64 (-.f64 x y))))
(/.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 y 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))) (fma.f64 (/.f64 (.f64 x x) (-.f64 x y)) (/.f64 (.f64 x x) (-.f64 x y)) (fma.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 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (*.f64 x x))))
(.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y y (-.f64 (.f64 x x) (.f64 x y)))))
(.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)))
(.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 y (-.f64 y x) (*.f64 x x)))))
(.f64 (neg.f64 (.f64 (+.f64 x y) (-.f64 x y))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 x y))))
(*.f64 #s(literal 1 binary64) (+.f64 x y))
(.f64 (.f64 (+.f64 x y) (-.f64 y 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 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 b (fma.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 (fma.f64 a a #s(literal -1/4 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (.f64 (fma.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 (fma.f64 a a #s(literal -1/4 binary64)) b)))
(/.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))))
(/.f64 (*.f64 b (fma.f64 a a #s(literal -1/4 binary64))) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))))
(/.f64 (*.f64 (fma.f64 a a #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (neg.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)))) (neg.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (neg.f64 (*.f64 b (fma.f64 a a #s(literal -1/4 binary64)))) (neg.f64 (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (neg.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b)) (neg.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 a a #s(literal -1/4 binary64)) b)) (neg.f64 (+.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))) (fma.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))) (fma.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 (fma.f64 a (*.f64 a a) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(.f64 (.f64 b (fma.f64 a a #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))))
(.f64 (.f64 (fma.f64 a (*.f64 a a) #s(literal -1/8 binary64)) b) (/.f64 #s(literal 1 binary64) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(.f64 (.f64 (fma.f64 a a #s(literal -1/4 binary64)) b) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))))
(log.f64 t)

eval151.0ms (1%)

Memory: 21.7MiB live, 189.3MiB allocated
Compiler: Compiled 25 603 to 1 899 computations (92.6% saved)

prune156.0ms (1%)

Memory

-3.0MiB live, 272.9MiB allocated

Pruning

20 alts after pruning (20 fresh and 0 done)

	Pruned	Kept	Total
New	635	20	655
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	636	20	656

Accuracy

100.0%

Counts

656 → 20

Alt Table

Click to see full alt table

Status	Accuracy	Program
	28.7%	(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
	99.7%	(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
	48.5%	(+.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))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶	99.9%	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (fma.f64 b a (.f64 b #s(literal -1/2 binary64))))
▶	86.4%	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) (*.f64 b a)))
▶	58.3%	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
	83.4%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
	78.8%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
	77.9%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 y (-.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (/.f64 (.f64 z (log.f64 t)) y)) y)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
	84.4%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 x (-.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (/.f64 (.f64 z (log.f64 t)) x)) x)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
	62.5%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (-.f64 z (.f64 z (log.f64 t)))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
▶	76.4%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
	86.2%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (.f64 x (neg.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x))))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
	6.2%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64))))
	14.1%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
	5.5%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))))
	56.9%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t))))
	20.2%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
	39.6%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
▶	27.2%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))

Compiler

Compiled 862 to 548 computations (36.4% saved)

simplify419.0ms (2.7%)

Memory

-5.8MiB live, 626.3MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 18 expressions of interest:

New	Metric	Score
cost-diff	0	(+.f64 x y)
cost-diff	0	(+.f64 (+.f64 x y) z)
cost-diff	0	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) (*.f64 b a)))
cost-diff	128	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
cost-diff	0	(+.f64 x y)
cost-diff	0	(+.f64 (+.f64 x y) z)
cost-diff	0	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
cost-diff	128	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
cost-diff	0	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
cost-diff	0	(+.f64 y x)
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x))
cost-diff	128	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
cost-diff	0	(*.f64 b a)
cost-diff	0	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
cost-diff	0	(+.f64 (+.f64 x y) z)
cost-diff	128	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
cost-diff	128	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (fma.f64 b a (.f64 b #s(literal -1/2 binary64))))
cost-diff	192	(fma.f64 b a (*.f64 b #s(literal -1/2 binary64)))

Rules

14 382×	`lower-fma.f32`
14 380×	`lower-fma.f64`
3 172×	`lower-+.f32`
3 158×	`lower-+.f64`
2 758×	`lower--.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	35	248
0	52	246
1	86	246
2	210	246
3	700	246
4	2017	246
5	4147	246
6	4937	246
7	6977	246
0	8188	234

Stop Event

1×	iter limit
1×	node limit
1×	iter limit

Calls

Call 1

Inputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (fma.f64 b a (.f64 b #s(literal -1/2 binary64))))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
(fma.f64 b a (*.f64 b #s(literal -1/2 binary64)))
b
a
(*.f64 b #s(literal -1/2 binary64))
#s(literal -1/2 binary64)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
(*.f64 b a)
b
a
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x))
(+.f64 y x)
y
x
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(-.f64 a #s(literal 1/2 binary64))
a
#s(literal 1/2 binary64)
b
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
#s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))
#s(literal -1/2 binary64)
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) (*.f64 b a)))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
#s(approx (* (- a 1/2) b) (*.f64 b a))
(*.f64 b a)
b
a

Outputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (fma.f64 b a (.f64 b #s(literal -1/2 binary64))))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))
(+.f64 (+.f64 x y) z)
(+.f64 x (+.f64 y z))
(+.f64 x y)
x
y
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
(fma.f64 b a (*.f64 b #s(literal -1/2 binary64)))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
b
a
(*.f64 b #s(literal -1/2 binary64))
#s(literal -1/2 binary64)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
(*.f64 b a)
b
a
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 y x)
(+.f64 x y)
y
x
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(-.f64 a #s(literal 1/2 binary64))
(+.f64 a #s(literal -1/2 binary64))
a
#s(literal 1/2 binary64)
b
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x (+.f64 y #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))
(+.f64 (+.f64 x y) z)
(+.f64 x (+.f64 y z))
(+.f64 x y)
x
y
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
#s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))
#s(literal -1/2 binary64)
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) (*.f64 b a)))
(+.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))
(+.f64 (+.f64 x y) z)
(+.f64 x (+.f64 y z))
(+.f64 x y)
x
y
z
(*.f64 z (log.f64 t))
(log.f64 t)
t
#s(approx (* (- a 1/2) b) (*.f64 b a))
(*.f64 b a)
b
a

localize129.0ms (0.8%)

Memory

15.5MiB live, 167.4MiB allocated

Localize:

Found 18 expressions of interest:

New	Metric	Score
accuracy	0	(log.f64 t)
accuracy	0.11328125	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
accuracy	0.25390625	(*.f64 z (log.f64 t))
accuracy	31.85435170549091	#s(approx (* (- a 1/2) b) (*.f64 b a))
accuracy	0	(log.f64 t)
accuracy	0.11328125	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
accuracy	0.25390625	(*.f64 z (log.f64 t))
accuracy	61.7734670007039	#s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))
accuracy	0	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
accuracy	0	(+.f64 y x)
accuracy	0.01953125	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
accuracy	23.203216474209835	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x))
accuracy	0	(*.f64 b a)
accuracy	46.60251402495313	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
accuracy	0	(*.f64 b #s(literal -1/2 binary64))
accuracy	0	(log.f64 t)
accuracy	0.11328125	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
accuracy	0.25390625	(*.f64 z (log.f64 t))

Samples

60.0ms

256×

valid

Compiler

Compiled 228 to 23 computations (89.9% saved)

Precisions

Click to see histograms. Total time spent on operations: 23.0ms

ival-add: 9.0ms (40% of total)

ival-mult: 7.0ms (31.1% of total)

ival-log: 4.0ms (17.8% of total)

ival-sub: 2.0ms (8.9% of total)

ival-true: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

series468.0ms (3%)

Memory

-14.2MiB live, 824.7MiB allocated

Counts

18 → 708

Calls

Call 1

Inputs
#<alt (fma.f64 b a (*.f64 b #s(literal -1/2 binary64)))>
#<alt (+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (fma.f64 b a (.f64 b #s(literal -1/2 binary64))))>
#<alt (-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))>
#<alt (+.f64 (+.f64 x y) z)>
#<alt #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))>
#<alt (*.f64 b a)>
#<alt (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))>
#<alt #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x))>
#<alt (+.f64 y x)>
#<alt (*.f64 (-.f64 a #s(literal 1/2 binary64)) b)>
#<alt (+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))>
#<alt (+.f64 x y)>
#<alt (+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) (*.f64 b a)))>
#<alt (*.f64 z (log.f64 t))>
#<alt (log.f64 t)>
#<alt (*.f64 b #s(literal -1/2 binary64))>
#<alt #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))>
#<alt #s(approx (* (- a 1/2) b) (*.f64 b a))>

Outputs
#<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 (* b (+ 1/2 (* -1 a))))>
#<alt (* -1 (* b (+ 1/2 (* -1 a))))>
#<alt (* -1 (* b (+ 1/2 (* -1 a))))>
#<alt (* -1 (* b (+ 1/2 (* -1 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 (- (+ 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 (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt x>
#<alt (* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))>
#<alt (- (+ x (+ 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 (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt y>
#<alt (* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))>
#<alt (+ x (+ y (+ (* -1/2 b) (* a b))))>
#<alt (+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))>
#<alt (+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))>
#<alt (+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))>
#<alt (* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))>
#<alt (* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (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 (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (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 (* -1 (* b (+ 1/2 (* -1 a))))>
#<alt (* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))>
#<alt (* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))>
#<alt (* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))>
#<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 (- (+ 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 (* b (- a 1/2))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<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 (- y (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<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 (- y (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (* a b)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<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 (- y (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<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 (- y (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<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 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 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 -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 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 (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt 1>
#<alt 1>
#<alt 1>
#<alt 1>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<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 (- y (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<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 (- y (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<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 (- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<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 (- y (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<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 (- y (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<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 -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 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 (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt 1>
#<alt 1>
#<alt 1>
#<alt 1>
#<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 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 (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt 1>
#<alt 1>
#<alt 1>
#<alt 1>

Calls

177 calls:

Time	Variable		Point	Expression
25.0ms	y	@	0	(+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2)))
22.0ms	t	@	inf	(log t)
21.0ms	t	@	0	(- (+ (+ x y) z) (* z (log t)))
18.0ms	b	@	0	(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
14.0ms	t	@	-inf	(+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2)))

simplify473.0ms (3%)

Memory

57.5MiB live, 783.9MiB allocated

Algorithm

1×	egg-herbie

Rules

10 248×	`lower-fma.f64`
10 248×	`lower-fma.f32`
4 392×	`lower-+.f64`
4 392×	`lower-+.f32`
4 326×	`lower-*.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	437	9455
1	1313	9378
2	4258	9228
0	8056	8675

Stop Event

1×	iter limit
1×	node limit

Counts

708 → 675

Calls

Call 1

Inputs
(* 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 (* b (+ 1/2 (* -1 a))))
(* -1 (* b (+ 1/2 (* -1 a))))
(* -1 (* b (+ 1/2 (* -1 a))))
(* -1 (* b (+ 1/2 (* -1 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)))))
(- (+ 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)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
x
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))
x
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))
(- (+ x (+ 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)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
y
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))
y
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))
(+ x (+ y (+ (* -1/2 b) (* a b))))
(+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))
(+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))
(+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (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)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (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))))
(* -1 (* b (+ 1/2 (* -1 a))))
(* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))
(* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))
(* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))
(- (+ 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)))))
(- (+ 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 (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a y) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* 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)))))
(- y (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(* 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))))
(- y (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(* a b)
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a y) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* 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)))))
(- y (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(* 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))))
(- y (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ 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))))))
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)))
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)))
-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 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)))))
(- a 1/2)
(- a 1/2)
(- a 1/2)
(- a 1/2)
(/ 1 b)
(/ 1 b)
(/ 1 b)
(/ 1 b)
1
1
1
1
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a y) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* 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)))))
(- y (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(* 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))))
(- y (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
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)))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a y) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* 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)))))
(- y (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(* 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))))
(- y (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(* 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)
-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 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)))))
(- a 1/2)
(- a 1/2)
(- a 1/2)
(- a 1/2)
(/ 1 b)
(/ 1 b)
(/ 1 b)
(/ 1 b)
1
1
1
1
-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 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)))))
(- a 1/2)
(- a 1/2)
(- a 1/2)
(- a 1/2)
(/ 1 b)
(/ 1 b)
(/ 1 b)
(/ 1 b)
1
1
1
1

Outputs
(* 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 (* b (+ 1/2 (* -1 a))))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* -1 (* b (+ 1/2 (* -1 a))))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* -1 (* b (+ 1/2 (* -1 a))))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* -1 (* b (+ 1/2 (* -1 a))))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* -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 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(* a (+ b (* -1/2 (/ b a))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(* a (+ b (* -1/2 (/ b a))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t)))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
x
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))
(+.f64 x (.f64 (-.f64 (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (.f64 (/.f64 b x) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (*.f64 z (log.f64 t)) x)) x))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))
(+.f64 x (.f64 (-.f64 (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (.f64 (/.f64 b x) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (*.f64 z (log.f64 t)) x)) x))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))
(+.f64 x (.f64 (-.f64 (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (.f64 (/.f64 b x) (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (*.f64 z (log.f64 t)) x)) x))
x
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))
(fma.f64 x (/.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x) x)
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))
(fma.f64 x (/.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x) x)
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))
(fma.f64 x (/.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x) x)
(- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) z)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
y
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (.f64 (/.f64 b y) (+.f64 a #s(literal -1/2 binary64)))) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (.f64 (/.f64 b y) (+.f64 a #s(literal -1/2 binary64)))) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (.f64 (/.f64 b y) (+.f64 a #s(literal -1/2 binary64)))) (-.f64 #s(literal 1 binary64) (/.f64 (*.f64 z (log.f64 t)) y))))
y
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))
(fma.f64 y (/.f64 (+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) z))) y) y)
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))
(fma.f64 y (/.f64 (+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) z))) y) y)
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))
(fma.f64 y (/.f64 (+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) z))) y) y)
(+ x (+ y (+ (* -1/2 b) (* a b))))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))
(.f64 z (+.f64 (+.f64 (+.f64 (/.f64 x z) (/.f64 y z)) (.f64 (/.f64 b z) (+.f64 a #s(literal -1/2 binary64)))) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))
(.f64 z (+.f64 (+.f64 (+.f64 (/.f64 x z) (/.f64 y z)) (.f64 (/.f64 b z) (+.f64 a #s(literal -1/2 binary64)))) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))
(.f64 z (+.f64 (+.f64 (+.f64 (/.f64 x z) (/.f64 y z)) (.f64 (/.f64 b z) (+.f64 a #s(literal -1/2 binary64)))) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* z (+ 1 (* -1 (log t))))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (/.f64 (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x)) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (/.f64 (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x)) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (/.f64 (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x)) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 x (-.f64 (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 x (-.f64 (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 x (-.f64 (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 x (-.f64 (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)) (*.f64 z (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))))))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(* 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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #s(literal 1/2 binary64))))
(* -1 (* b (+ 1/2 (* -1 a))))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))
(*.f64 (neg.f64 b) (-.f64 #s(literal 1/2 binary64) (+.f64 a (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x)) b))))
(* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))
(*.f64 (neg.f64 b) (-.f64 #s(literal 1/2 binary64) (+.f64 a (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x)) b))))
(* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))
(*.f64 (neg.f64 b) (-.f64 #s(literal 1/2 binary64) (+.f64 a (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x)) b))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 (+.f64 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (+.f64 (+.f64 b (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 x a))) (+.f64 (/.f64 y a) (/.f64 z a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (+.f64 (+.f64 b (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 x a))) (+.f64 (/.f64 y a) (/.f64 z a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (+.f64 (+.f64 b (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 x a))) (+.f64 (/.f64 y a) (/.f64 z 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 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (+.f64 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (+.f64 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(- (+ y z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.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 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)))
(fma.f64 x (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x) x)
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(fma.f64 x (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x) x)
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(fma.f64 x (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x) x)
(- (+ x z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.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 (/.f64 x y) (+.f64 #s(literal 1 binary64) (/.f64 z y))) (/.f64 (.f64 z (log.f64 t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(.f64 y (-.f64 (+.f64 (/.f64 x y) (+.f64 #s(literal 1 binary64) (/.f64 z y))) (/.f64 (.f64 z (log.f64 t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(.f64 y (-.f64 (+.f64 (/.f64 x y) (+.f64 #s(literal 1 binary64) (/.f64 z y))) (/.f64 (.f64 z (log.f64 t)) y)))
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(fma.f64 y (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y) y)
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(fma.f64 y (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y) y)
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(fma.f64 y (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y) y)
(+ x y)
(+.f64 y x)
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* 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))))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (/.f64 (+.f64 y x) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (/.f64 (+.f64 y x) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (/.f64 (+.f64 y x) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 z (+.f64 y x)))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 z (+.f64 y x)))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 z (+.f64 y x)))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 z (+.f64 y x)))
(+ 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))))
(fma.f64 x (+.f64 (/.f64 y x) (/.f64 z x)) x)
(* x (+ 1 (+ (/ y x) (/ z x))))
(fma.f64 x (+.f64 (/.f64 y x) (/.f64 z x)) x)
(* x (+ 1 (+ (/ y x) (/ z x))))
(fma.f64 x (+.f64 (/.f64 y x) (/.f64 z x)) x)
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(fma.f64 x (/.f64 (+.f64 y z) x) x)
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(fma.f64 x (/.f64 (+.f64 y z) x) x)
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(fma.f64 x (/.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))))
(fma.f64 y (+.f64 (/.f64 x y) (/.f64 z y)) y)
(* y (+ 1 (+ (/ x y) (/ z y))))
(fma.f64 y (+.f64 (/.f64 x y) (/.f64 z y)) y)
(* y (+ 1 (+ (/ x y) (/ z y))))
(fma.f64 y (+.f64 (/.f64 x y) (/.f64 z y)) y)
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(fma.f64 y (/.f64 (+.f64 z x) y) y)
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(fma.f64 y (/.f64 (+.f64 z x) y) y)
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(fma.f64 y (/.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))))
(fma.f64 z (+.f64 (/.f64 x z) (/.f64 y z)) z)
(* z (+ 1 (+ (/ x z) (/ y z))))
(fma.f64 z (+.f64 (/.f64 x z) (/.f64 y z)) z)
(* z (+ 1 (+ (/ x z) (/ y z))))
(fma.f64 z (+.f64 (/.f64 x z) (/.f64 y z)) z)
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(fma.f64 z (/.f64 (+.f64 y x) z) z)
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(fma.f64 z (/.f64 (+.f64 y x) z) z)
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(fma.f64 z (/.f64 (+.f64 y x) z) z)
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 x (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 #s(literal 1/2 binary64) (/.f64 x (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)))) (/.f64 #s(literal -1 binary64) (*.f64 x (+.f64 #s(literal -1/2 binary64) (+.f64 a y)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 z (+.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x x) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (.f64 x (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(+.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x x) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (+.f64 (/.f64 #s(literal -1 binary64) (.f64 x (+.f64 #s(literal -1/2 binary64) (+.f64 a y)))) (/.f64 #s(literal -1/3 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (+.f64 #s(literal -1/2 binary64) (+.f64 a y))) (.f64 x (*.f64 x x)))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal -1 binary64) (*.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) y)))) (-.f64 (-.f64 z (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 z (+.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) y))) (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (+.f64 (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (/.f64 #s(literal 1/3 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (.f64 y (*.f64 y y)))))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (fma.f64 #s(literal 1/2 binary64) (/.f64 z (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal -1 binary64) (*.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 z (.f64 z (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))))) (-.f64 (-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 z (.f64 z (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))) (+.f64 (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (.f64 (.f64 (*.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) z) z)))))))
(- (+ a y) 1/2)
(+.f64 #s(literal -1/2 binary64) (+.f64 a y))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a y) (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a y) (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a y) (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) #s(literal -1/2 binary64)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 b #s(literal -1/2 binary64) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 z x)))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (fma.f64 a (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x)))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (fma.f64 a (fma.f64 #s(literal -1/3 binary64) (/.f64 a (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(*.f64 a (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b) (-.f64 (/.f64 y a) (/.f64 (log.f64 a) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a))) (-.f64 (-.f64 b (/.f64 x (.f64 a a))) (+.f64 (/.f64 z (.f64 a a)) (/.f64 (log.f64 a) a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))) (.f64 a (.f64 a a))) (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a)))) (-.f64 (-.f64 b (/.f64 x (.f64 a a))) (+.f64 (/.f64 z (*.f64 a a)) (/.f64 (log.f64 a) 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 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (+.f64 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (+.f64 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(- y (log (- (+ a (+ x z)) 1/2)))
(-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(* 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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #s(literal 1/2 binary64))))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) b) (log1p.f64 (+.f64 z x))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) b) (log1p.f64 (+.f64 z x))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) b) (log1p.f64 (+.f64 z x))))
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(* a b)
(*.f64 b a)
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 x (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 #s(literal 1/2 binary64) (/.f64 x (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)))) (/.f64 #s(literal -1 binary64) (*.f64 x (+.f64 #s(literal -1/2 binary64) (+.f64 a y)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 z (+.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x x) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (.f64 x (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(+.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x x) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (+.f64 (/.f64 #s(literal -1 binary64) (.f64 x (+.f64 #s(literal -1/2 binary64) (+.f64 a y)))) (/.f64 #s(literal -1/3 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (+.f64 #s(literal -1/2 binary64) (+.f64 a y))) (.f64 x (*.f64 x x)))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal -1 binary64) (*.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) y)))) (-.f64 (-.f64 z (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 z (+.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) y))) (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (+.f64 (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (/.f64 #s(literal 1/3 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (.f64 y (*.f64 y y)))))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (fma.f64 #s(literal 1/2 binary64) (/.f64 z (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal -1 binary64) (*.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 z (.f64 z (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))))) (-.f64 (-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 z (.f64 z (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))) (+.f64 (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (.f64 (.f64 (*.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) z) z)))))))
(- (+ a y) 1/2)
(+.f64 #s(literal -1/2 binary64) (+.f64 a y))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a y) (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a y) (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a y) (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) #s(literal -1/2 binary64)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 b #s(literal -1/2 binary64) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 z x)))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (fma.f64 a (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x)))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (fma.f64 a (fma.f64 #s(literal -1/3 binary64) (/.f64 a (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(*.f64 a (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b) (-.f64 (/.f64 y a) (/.f64 (log.f64 a) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a))) (-.f64 (-.f64 b (/.f64 x (.f64 a a))) (+.f64 (/.f64 z (.f64 a a)) (/.f64 (log.f64 a) a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))) (.f64 a (.f64 a a))) (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a)))) (-.f64 (-.f64 b (/.f64 x (.f64 a a))) (+.f64 (/.f64 z (*.f64 a a)) (/.f64 (log.f64 a) 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 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (+.f64 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (+.f64 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(- y (log (- (+ a (+ x z)) 1/2)))
(-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(* 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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #s(literal 1/2 binary64))))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) b) (log1p.f64 (+.f64 z x))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) b) (log1p.f64 (+.f64 z x))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) b) (log1p.f64 (+.f64 z x))))
(- (+ y z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.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 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)))
(fma.f64 x (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x) x)
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(fma.f64 x (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x) x)
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(fma.f64 x (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x) x)
(- (+ x z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.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 (/.f64 x y) (+.f64 #s(literal 1 binary64) (/.f64 z y))) (/.f64 (.f64 z (log.f64 t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(.f64 y (-.f64 (+.f64 (/.f64 x y) (+.f64 #s(literal 1 binary64) (/.f64 z y))) (/.f64 (.f64 z (log.f64 t)) y)))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(.f64 y (-.f64 (+.f64 (/.f64 x y) (+.f64 #s(literal 1 binary64) (/.f64 z y))) (/.f64 (.f64 z (log.f64 t)) y)))
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(fma.f64 y (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y) y)
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(fma.f64 y (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y) y)
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(fma.f64 y (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y) y)
(+ x y)
(+.f64 y x)
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* 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))))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (/.f64 (+.f64 y x) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (/.f64 (+.f64 y x) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 z (+.f64 (/.f64 (+.f64 y x) z) (-.f64 #s(literal 1 binary64) (log.f64 t))))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 z (+.f64 y x)))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 z (+.f64 y x)))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 z (+.f64 y x)))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 z (+.f64 y x)))
x
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
y
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(fma.f64 y (/.f64 x y) y)
(* -1 (* y (- (* -1 (/ x y)) 1)))
(fma.f64 y (/.f64 x y) y)
(* -1 (* y (- (* -1 (/ x y)) 1)))
(fma.f64 y (/.f64 x y) y)
y
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
x
(* x (+ 1 (/ y x)))
(fma.f64 x (/.f64 y x) x)
(* x (+ 1 (/ y x)))
(fma.f64 x (/.f64 y x) x)
(* x (+ 1 (/ y x)))
(fma.f64 x (/.f64 y x) x)
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(fma.f64 x (/.f64 y x) x)
(* -1 (* x (- (* -1 (/ y x)) 1)))
(fma.f64 x (/.f64 y x) x)
(* -1 (* x (- (* -1 (/ y x)) 1)))
(fma.f64 x (/.f64 y x) x)
-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 a (/.f64 #s(literal -1/2 binary64) a)))
(* a (- 1 (* 1/2 (/ 1 a))))
(+.f64 a (*.f64 a (/.f64 #s(literal -1/2 binary64) a)))
(* a (- 1 (* 1/2 (/ 1 a))))
(+.f64 a (*.f64 a (/.f64 #s(literal -1/2 binary64) a)))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(- 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 1/2)
(+.f64 a #s(literal -1/2 binary64))
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 x (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 #s(literal 1/2 binary64) (/.f64 x (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)))) (/.f64 #s(literal -1 binary64) (*.f64 x (+.f64 #s(literal -1/2 binary64) (+.f64 a y)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 z (+.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x x) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (.f64 x (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(+.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x x) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (+.f64 (/.f64 #s(literal -1 binary64) (.f64 x (+.f64 #s(literal -1/2 binary64) (+.f64 a y)))) (/.f64 #s(literal -1/3 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (+.f64 #s(literal -1/2 binary64) (+.f64 a y))) (.f64 x (*.f64 x x)))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal -1 binary64) (*.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) y)))) (-.f64 (-.f64 z (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 z (+.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) y))) (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (+.f64 (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (/.f64 #s(literal 1/3 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (.f64 y (*.f64 y y)))))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (fma.f64 #s(literal 1/2 binary64) (/.f64 z (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal -1 binary64) (*.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 z (.f64 z (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))))) (-.f64 (-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 z (.f64 z (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))) (+.f64 (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (.f64 (.f64 (*.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) z) z)))))))
(- (+ a y) 1/2)
(+.f64 #s(literal -1/2 binary64) (+.f64 a y))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a y) (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a y) (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a y) (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) #s(literal -1/2 binary64)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 b #s(literal -1/2 binary64) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 z x)))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (fma.f64 a (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x)))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (fma.f64 a (fma.f64 #s(literal -1/3 binary64) (/.f64 a (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(*.f64 a (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b) (-.f64 (/.f64 y a) (/.f64 (log.f64 a) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a))) (-.f64 (-.f64 b (/.f64 x (.f64 a a))) (+.f64 (/.f64 z (.f64 a a)) (/.f64 (log.f64 a) a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))) (.f64 a (.f64 a a))) (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a)))) (-.f64 (-.f64 b (/.f64 x (.f64 a a))) (+.f64 (/.f64 z (*.f64 a a)) (/.f64 (log.f64 a) 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 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (+.f64 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (+.f64 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(- y (log (- (+ a (+ x z)) 1/2)))
(-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(* 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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #s(literal 1/2 binary64))))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) b) (log1p.f64 (+.f64 z x))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) b) (log1p.f64 (+.f64 z x))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) b) (log1p.f64 (+.f64 z x))))
y
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
x
(* x (+ 1 (/ y x)))
(fma.f64 x (/.f64 y x) x)
(* x (+ 1 (/ y x)))
(fma.f64 x (/.f64 y x) x)
(* x (+ 1 (/ y x)))
(fma.f64 x (/.f64 y x) x)
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(fma.f64 x (/.f64 y x) x)
(* -1 (* x (- (* -1 (/ y x)) 1)))
(fma.f64 x (/.f64 y x) x)
(* -1 (* x (- (* -1 (/ y x)) 1)))
(fma.f64 x (/.f64 y x) x)
x
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
y
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(fma.f64 y (/.f64 x y) y)
(* -1 (* y (- (* -1 (/ x y)) 1)))
(fma.f64 y (/.f64 x y) y)
(* -1 (* y (- (* -1 (/ x y)) 1)))
(fma.f64 y (/.f64 x y) y)
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 x (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 #s(literal 1/2 binary64) (/.f64 x (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)))) (/.f64 #s(literal -1 binary64) (*.f64 x (+.f64 #s(literal -1/2 binary64) (+.f64 a y)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 z (+.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x x) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (.f64 x (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(+.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x x) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y))))) (+.f64 (/.f64 #s(literal -1 binary64) (.f64 x (+.f64 #s(literal -1/2 binary64) (+.f64 a y)))) (/.f64 #s(literal -1/3 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a y)) (+.f64 #s(literal -1/2 binary64) (+.f64 a y))) (.f64 x (*.f64 x x)))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal -1 binary64) (*.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) y)))) (-.f64 (-.f64 z (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 z (+.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) y))) (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (.f64 y (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (+.f64 (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (/.f64 #s(literal 1/3 binary64) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (.f64 y (*.f64 y y)))))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (fma.f64 #s(literal 1/2 binary64) (/.f64 z (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal -1 binary64) (*.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 z (.f64 z (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))))) (-.f64 (-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x))))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 z (.f64 z (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))))) (+.f64 (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x)))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a x)) (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) (.f64 (.f64 (*.f64 z (+.f64 #s(literal -1/2 binary64) (+.f64 a x))) z) z)))))))
(- (+ a y) 1/2)
(+.f64 #s(literal -1/2 binary64) (+.f64 a y))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a y) (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a y) (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (+.f64 a y) (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) #s(literal -1/2 binary64)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 b #s(literal -1/2 binary64) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 z x)))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (fma.f64 a (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x)))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (fma.f64 a (fma.f64 #s(literal -1/3 binary64) (/.f64 a (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x))))
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(*.f64 a (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b) (-.f64 (/.f64 y a) (/.f64 (log.f64 a) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a))) (-.f64 (-.f64 b (/.f64 x (.f64 a a))) (+.f64 (/.f64 z (.f64 a a)) (/.f64 (log.f64 a) a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z x)) (+.f64 #s(literal -1/2 binary64) (+.f64 z x))) (.f64 a (.f64 a a))) (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a)))) (-.f64 (-.f64 b (/.f64 x (.f64 a a))) (+.f64 (/.f64 z (*.f64 a a)) (/.f64 (log.f64 a) 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 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (+.f64 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 a (+.f64 b (/.f64 (+.f64 (+.f64 y x) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))) a)))
(- y (log (- (+ a (+ x z)) 1/2)))
(-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 a (+.f64 z x)))))
(* 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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #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 y b) (/.f64 z b)) (+.f64 a (/.f64 x b))) (fma.f64 (log.f64 t) (/.f64 z b) #s(literal 1/2 binary64))))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) b) (log1p.f64 (+.f64 z x))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) b) (log1p.f64 (+.f64 z x))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) b) (log1p.f64 (+.f64 z x))))
(* 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 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))
-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 a (/.f64 #s(literal -1/2 binary64) a)))
(* a (- 1 (* 1/2 (/ 1 a))))
(+.f64 a (*.f64 a (/.f64 #s(literal -1/2 binary64) a)))
(* a (- 1 (* 1/2 (/ 1 a))))
(+.f64 a (*.f64 a (/.f64 #s(literal -1/2 binary64) a)))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(- 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 1/2)
(+.f64 a #s(literal -1/2 binary64))
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 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 a (/.f64 #s(literal -1/2 binary64) a)))
(* a (- 1 (* 1/2 (/ 1 a))))
(+.f64 a (*.f64 a (/.f64 #s(literal -1/2 binary64) a)))
(* a (- 1 (* 1/2 (/ 1 a))))
(+.f64 a (*.f64 a (/.f64 #s(literal -1/2 binary64) a)))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 a (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b))
(- 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 1/2)
(+.f64 a #s(literal -1/2 binary64))
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)

rewrite335.0ms (2.2%)

Memory

-14.5MiB live, 591.2MiB allocated

Rules

5 894×	`lower-*.f32`
5 886×	`lower-*.f64`
3 746×	`lower-/.f64`
3 746×	`lower-/.f32`
2 516×	`lower--.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	35	169
0	52	167
1	212	167
2	1864	167
0	8430	164

Stop Event

1×	iter limit
1×	node limit
1×	iter limit

Counts

18 → 509

Calls

Call 1

Inputs
(fma.f64 b a (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (fma.f64 b a (.f64 b #s(literal -1/2 binary64))))
(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
(+.f64 (+.f64 x y) z)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
(*.f64 b a)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x))
(+.f64 y x)
(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 x y)
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) (*.f64 b a)))
(*.f64 z (log.f64 t))
(log.f64 t)
(*.f64 b #s(literal -1/2 binary64))
#s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))
#s(approx (* (- a 1/2) b) (*.f64 b a))

Outputs
(+.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a))
(+.f64 (.f64 b a) (.f64 b #s(literal -1/2 binary64)))
(-.f64 (/.f64 (.f64 b (.f64 a (.f64 b a))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))) (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (*.f64 b (-.f64 a #s(literal -1/2 binary64)))))
(fma.f64 b a (*.f64 b #s(literal -1/2 binary64)))
(fma.f64 b #s(literal -1/2 binary64) (*.f64 b a))
(fma.f64 a b (*.f64 b #s(literal -1/2 binary64)))
(fma.f64 #s(literal -1/2 binary64) b (*.f64 b a))
(/.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (*.f64 b a)))))
(/.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (fma.f64 #s(literal 1/4 binary64) (.f64 b b) (-.f64 (.f64 b (.f64 a (.f64 b a))) (.f64 b (.f64 a (.f64 b #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 b (-.f64 a #s(literal -1/2 binary64))))
(/.f64 (neg.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64)))) (neg.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (*.f64 b a))))))
(/.f64 (neg.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64)))) (neg.f64 (fma.f64 #s(literal 1/4 binary64) (.f64 b b) (-.f64 (.f64 b (.f64 a (.f64 b a))) (.f64 b (.f64 a (.f64 b #s(literal -1/2 binary64))))))))
(/.f64 (neg.f64 (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64))))) (neg.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))))
(/.f64 #s(literal 1 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 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.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 #s(literal 1/4 binary64) (.f64 b b)) (.f64 b (.f64 a (.f64 b a)))) (-.f64 (.f64 b #s(literal -1/2 binary64)) (*.f64 b a)))
(/.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))))
(/.f64 (*.f64 b (fma.f64 a a #s(literal -1/4 binary64))) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))))
(/.f64 (*.f64 (fma.f64 a a #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (-.f64 (.f64 (.f64 b (.f64 a (.f64 b a))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64))) (.f64 #s(literal 1/4 binary64) (.f64 b b)))) (.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))))) (neg.f64 (neg.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (*.f64 b a)))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))))) (neg.f64 (neg.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (-.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (.f64 b (.f64 a (.f64 b a))))) (neg.f64 (-.f64 (.f64 b #s(literal -1/2 binary64)) (*.f64 b a))))
(/.f64 (neg.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)))) (neg.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (neg.f64 (*.f64 b (fma.f64 a a #s(literal -1/4 binary64)))) (neg.f64 (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (neg.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b)) (neg.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 a a #s(literal -1/4 binary64)) b)) (neg.f64 (+.f64 a #s(literal 1/2 binary64))))
(pow.f64 (/.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.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 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a))))))
(.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))))
(+.f64 (*.f64 b #s(literal -1/2 binary64)) (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))))
(+.f64 x (-.f64 (+.f64 y z) (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 (+.f64 x y) (+.f64 (-.f64 z (.f64 z (log.f64 t))) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(+.f64 (+.f64 x y) (-.f64 z (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 z (-.f64 (+.f64 x y) (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 (+.f64 y (+.f64 x z)) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(+.f64 (+.f64 y (+.f64 x z)) (fma.f64 (log.f64 t) (neg.f64 z) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(+.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(+.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))))
(+.f64 (*.f64 b a) (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))))
(+.f64 (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (+.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) (.f64 b #s(literal -1/2 binary64))) (.f64 b a))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (+.f64 x y)) (-.f64 z (*.f64 z (log.f64 t))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (+.f64 y (+.f64 x z))) (*.f64 (log.f64 t) (neg.f64 z)))
(-.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(-.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (+.f64 y (+.f64 x z))) (*.f64 z (log.f64 t)))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))))
(fma.f64 b #s(literal -1/2 binary64) (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))))
(fma.f64 a b (fma.f64 b #s(literal -1/2 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))))
(fma.f64 #s(literal -1/2 binary64) b (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x (-.f64 x y) (.f64 y y))) (+.f64 (-.f64 z (.f64 z (log.f64 t))) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x (-.f64 x y) (.f64 y y))) (-.f64 z (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (.f64 y (-.f64 y x)))) (+.f64 (-.f64 z (.f64 z (log.f64 t))) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (.f64 y (-.f64 y x)))) (-.f64 z (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (*.f64 b a))))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (fma.f64 (log.f64 t) (neg.f64 z) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))))) (.f64 b (+.f64 a #s(literal -1/2 binary64))))
(fma.f64 (.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) (+.f64 (-.f64 z (.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(fma.f64 (.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) (-.f64 z (-.f64 (.f64 z (log.f64 t)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (+.f64 (-.f64 z (.f64 z (log.f64 t))) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (-.f64 z (-.f64 (.f64 z (log.f64 t)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))))
(fma.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))) (fma.f64 (log.f64 t) (neg.f64 z) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z)))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(/.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))))
(/.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (.f64 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))))) (.f64 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a))))))
(/.f64 (fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64))) (.f64 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))))) (.f64 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))))
(/.f64 (fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))))) (.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (*.f64 b a))))))
(/.f64 (fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64))) (.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))))) (.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (*.f64 b (-.f64 a #s(literal -1/2 binary64)))))
(/.f64 (fma.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))))) (.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))))))
(/.f64 (fma.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))))) (.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (*.f64 b a)))) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z)))))
(/.f64 (fma.f64 (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))))) (.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64))) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))))))
(/.f64 (fma.f64 (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))))) (.f64 (*.f64 b (-.f64 a #s(literal -1/2 binary64))) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z)))))
(/.f64 (neg.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (+.f64 (pow.f64 (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) #s(literal 3 binary64)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (+.f64 (pow.f64 (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) #s(literal 2 binary64)) (-.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (.f64 (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 3 binary64))) (fma.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)) (+.f64 (pow.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 2 binary64)) (.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))))
(/.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))))
(/.f64 (-.f64 (pow.f64 (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) #s(literal 2 binary64)) (.f64 #s(literal 1/4 binary64) (.f64 b b))) (-.f64 (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (*.f64 b #s(literal -1/2 binary64))))
(/.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 2 binary64))) (+.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (.f64 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))) (.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (.f64 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (.f64 (fma.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 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))) (.f64 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (.f64 (fma.f64 z z (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (.f64 (+.f64 x y) z))) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #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 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))) (.f64 (+.f64 x (-.f64 y z)) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 (+.f64 x (-.f64 y z)) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (.f64 (+.f64 x (-.f64 y z)) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (.f64 (neg.f64 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))) (.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (.f64 (neg.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (.f64 (neg.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #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 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (.f64 (neg.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (.f64 (neg.f64 (+.f64 x (-.f64 y z))) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (.f64 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (.f64 (fma.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 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))) (.f64 (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 y z) (.f64 (+.f64 y z) (+.f64 y z)))) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (.f64 (fma.f64 x x (-.f64 (.f64 (+.f64 y z) (+.f64 y z)) (.f64 x (+.f64 y z)))) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (.f64 (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.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 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))) (.f64 (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.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 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (.f64 (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (fma.f64 z (log.f64 t) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (.f64 (/.f64 (+.f64 x (-.f64 y z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))) (.f64 (/.f64 (+.f64 x (-.f64 y z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 (/.f64 (+.f64 x (-.f64 y z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (.f64 (/.f64 (+.f64 x (-.f64 y z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (fma.f64 z (log.f64 t) (*.f64 b (+.f64 a #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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #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 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))) (.f64 (-.f64 x (+.f64 y z)) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (.f64 (-.f64 (.f64 x x) (.f64 (+.f64 y z) (+.f64 y z))) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 (-.f64 x (+.f64 y z)) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (.f64 (-.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (*.f64 b (+.f64 a #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)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #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 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))) (.f64 (-.f64 z (+.f64 x y)) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 z (log.f64 t)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (.f64 (-.f64 (.f64 z z) (.f64 (+.f64 x y) (+.f64 x y))) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 (-.f64 z (+.f64 x y)) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (.f64 (-.f64 z (+.f64 x y)) (fma.f64 z (log.f64 t) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (.f64 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64)))))) (neg.f64 (.f64 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))))))
(/.f64 (neg.f64 (fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64))) (.f64 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (.f64 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (.f64 b (-.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64)))))) (neg.f64 (.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (*.f64 b a)))))))
(/.f64 (neg.f64 (fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64))) (.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (*.f64 b (-.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (fma.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)))))) (neg.f64 (.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))))))
(/.f64 (neg.f64 (fma.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)))))) (neg.f64 (.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (*.f64 b a)))) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)))))) (neg.f64 (.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64))) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)))))) (neg.f64 (.f64 (*.f64 b (-.f64 a #s(literal -1/2 binary64))) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))))) (neg.f64 (neg.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) #s(literal 3 binary64)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64)))) (neg.f64 (+.f64 (pow.f64 (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) #s(literal 2 binary64)) (-.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (.f64 (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (*.f64 b #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)) (+.f64 (pow.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 2 binary64)) (.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))))
(/.f64 (neg.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) #s(literal 2 binary64)) (.f64 #s(literal 1/4 binary64) (.f64 b b)))) (neg.f64 (-.f64 (fma.f64 b a (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (*.f64 b #s(literal -1/2 binary64)))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (-.f64 (.f64 z (log.f64 t)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) #s(literal 2 binary64)))) (neg.f64 (+.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(pow.f64 (/.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))) #s(literal -1 binary64))
(.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)))))
(.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(+.f64 x (+.f64 y (-.f64 z (*.f64 z (log.f64 t)))))
(+.f64 x (+.f64 (+.f64 y z) (*.f64 (log.f64 t) (neg.f64 z))))
(+.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 (log.f64 t) (neg.f64 z))))
(+.f64 z (-.f64 (+.f64 x y) (*.f64 z (log.f64 t))))
(+.f64 (+.f64 y (+.f64 x z)) (*.f64 (log.f64 t) (neg.f64 z)))
(+.f64 (*.f64 (log.f64 t) (neg.f64 z)) (+.f64 y (+.f64 x z)))
(+.f64 (-.f64 z (*.f64 z (log.f64 t))) (+.f64 x y))
(-.f64 (+.f64 y (+.f64 x z)) (*.f64 z (log.f64 t)))
(-.f64 (/.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))))) (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (*.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))))))
(-.f64 (/.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z)))) (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z)))))
(fma.f64 z (neg.f64 (log.f64 t)) (+.f64 y (+.f64 x z)))
(fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x (-.f64 x y) (.f64 y y))) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (.f64 y (-.f64 y x)))) (-.f64 z (*.f64 z (log.f64 t))))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (*.f64 (log.f64 t) (neg.f64 z)))
(fma.f64 (.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) (-.f64 z (.f64 z (log.f64 t))))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (-.f64 z (.f64 z (log.f64 t))))
(fma.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))) (.f64 (log.f64 t) (neg.f64 z)))
(fma.f64 (neg.f64 z) (log.f64 t) (+.f64 y (+.f64 x z)))
(fma.f64 #s(literal -1 binary64) (*.f64 z (log.f64 t)) (+.f64 y (+.f64 x z)))
(fma.f64 (neg.f64 (log.f64 t)) z (+.f64 y (+.f64 x z)))
(/.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (*.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))))
(/.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (fma.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 (+.f64 y (+.f64 x z)) (.f64 (log.f64 t) (neg.f64 z))))))
(/.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))))
(/.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (-.f64 (+.f64 y (+.f64 x z)) (*.f64 (log.f64 t) (neg.f64 z))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (*.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 (+.f64 y (+.f64 x z)) (.f64 (log.f64 t) (neg.f64 z)))))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)))) (neg.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z)))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 y (+.f64 x z)) (*.f64 (log.f64 t) (neg.f64 z)))))
(/.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (.f64 z (log.f64 t))) #s(literal 3 binary64))) (fma.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 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))))))
(/.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 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))))) (.f64 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)))) (pow.f64 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (*.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) #s(literal 2 binary64)))
(/.f64 (-.f64 (.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z)))) (.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)))) (pow.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)))
(/.f64 (neg.f64 (neg.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (*.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))))))
(/.f64 (neg.f64 (fma.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 (fma.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 (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))))))
(.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z)))))
(+.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 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x (-.f64 x y) (.f64 y y))) z)
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (.f64 y (-.f64 y x)))) z)
(fma.f64 (*.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) z)
(fma.f64 (*.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) z)
(/.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))))
(/.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (fma.f64 z z (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))))
(/.f64 (*.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (+.f64 x (-.f64 y z)))
(/.f64 (neg.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))))
(/.f64 (neg.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (neg.f64 (fma.f64 z z (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z)))))
(/.f64 (neg.f64 (*.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (neg.f64 (+.f64 x (-.f64 y z))))
(/.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 y z) (.f64 (+.f64 y z) (+.f64 y z)))) (fma.f64 x x (-.f64 (.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x (+.f64 y z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.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 y (+.f64 x z)) (+.f64 x (-.f64 y z)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.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 y (+.f64 x 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 (.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 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))))) (neg.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))))) (neg.f64 (neg.f64 (+.f64 x (-.f64 y z)))))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 y z) (.f64 (+.f64 y z) (+.f64 y z))))) (neg.f64 (fma.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 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.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 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) #s(literal -1 binary64))
(.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (*.f64 (+.f64 x y) (+.f64 x y)))))
(.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
(*.f64 b a)
(*.f64 a b)
(+.f64 (.f64 b #s(literal -1/2 binary64)) (fma.f64 b a #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))
(+.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))
(+.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(+.f64 (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b #s(literal -1/2 binary64))) (.f64 b a))
(+.f64 (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b a)) (.f64 b #s(literal -1/2 binary64)))
(-.f64 (/.f64 (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(fma.f64 b #s(literal -1/2 binary64) (fma.f64 b a #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(fma.f64 a b (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(fma.f64 #s(literal -1/2 binary64) b (fma.f64 b a #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(fma.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a))))) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))
(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(/.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))))
(/.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
(/.f64 (.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))
(/.f64 (neg.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))))) (neg.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
(/.f64 (neg.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))))) (neg.f64 (fma.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))))))
(/.f64 (neg.f64 (.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))))) (neg.f64 (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))))
(/.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))
(/.f64 (-.f64 (.f64 (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (.f64 (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))) (neg.f64 (neg.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))))) (neg.f64 (neg.f64 (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (neg.f64 (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))
(pow.f64 (/.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))))) #s(literal -1 binary64))
(.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
(.f64 (.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
(+.f64 y x)
(-.f64 (/.f64 (.f64 y y) (-.f64 y x)) (/.f64 (.f64 x x) (-.f64 y x)))
(-.f64 (/.f64 (.f64 x x) (-.f64 x y)) (/.f64 (.f64 y y) (-.f64 x y)))
(/.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 x (-.f64 x y) (.f64 y y)))
(/.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 x x (.f64 y (-.f64 y x))))
(/.f64 (*.f64 (+.f64 x y) (-.f64 y x)) (-.f64 y x))
(/.f64 (*.f64 (+.f64 x y) (-.f64 x y)) (-.f64 x y))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 x (-.f64 x y) (.f64 y y))))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 x x (.f64 y (-.f64 y x)))))
(/.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 y x))) (neg.f64 (-.f64 y x)))
(/.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y))) (neg.f64 (-.f64 x y)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x x (.f64 y (-.f64 y x))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 y x) (*.f64 (+.f64 x y) (-.f64 y x))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 x y) (*.f64 (+.f64 x y) (-.f64 x y))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 x x (.f64 y (-.f64 y x))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 y x) (*.f64 (+.f64 x y) (-.f64 y x)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 x y) (*.f64 (+.f64 x y) (-.f64 x y)))))
(/.f64 (-.f64 (.f64 (.f64 y y) (-.f64 y x)) (.f64 (-.f64 y x) (.f64 x x))) (*.f64 (-.f64 y 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 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))) (neg.f64 (neg.f64 (fma.f64 x (-.f64 x y) (.f64 y y)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))) (neg.f64 (neg.f64 (fma.f64 x x (.f64 y (-.f64 y x))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 y x)))) (neg.f64 (neg.f64 (-.f64 y x))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y)))) (neg.f64 (neg.f64 (-.f64 x y))))
(pow.f64 (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 x x (.f64 y (-.f64 y x))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 y x) (*.f64 (+.f64 x y) (-.f64 y x))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 x y) (*.f64 (+.f64 x y) (-.f64 x y))) #s(literal -1 binary64))
(.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x (-.f64 x y) (*.f64 y y))))
(.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (*.f64 y (-.f64 y x)))))
(.f64 (.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)))
(.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)))
(+.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a))
(+.f64 (.f64 b a) (.f64 b #s(literal -1/2 binary64)))
(-.f64 (/.f64 (.f64 b (.f64 a (.f64 b a))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))) (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (*.f64 b (-.f64 a #s(literal -1/2 binary64)))))
(fma.f64 b a (*.f64 b #s(literal -1/2 binary64)))
(fma.f64 b #s(literal -1/2 binary64) (*.f64 b a))
(fma.f64 a b (*.f64 b #s(literal -1/2 binary64)))
(fma.f64 #s(literal -1/2 binary64) b (*.f64 b a))
(/.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (*.f64 b a)))))
(/.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (fma.f64 #s(literal 1/4 binary64) (.f64 b b) (-.f64 (.f64 b (.f64 a (.f64 b a))) (.f64 b (.f64 a (.f64 b #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 b (-.f64 a #s(literal -1/2 binary64))))
(/.f64 (neg.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64)))) (neg.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (*.f64 b a))))))
(/.f64 (neg.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64)))) (neg.f64 (fma.f64 #s(literal 1/4 binary64) (.f64 b b) (-.f64 (.f64 b (.f64 a (.f64 b a))) (.f64 b (.f64 a (.f64 b #s(literal -1/2 binary64))))))))
(/.f64 (neg.f64 (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64))))) (neg.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))))
(/.f64 #s(literal 1 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 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (*.f64 b b)) #s(literal -1/8 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.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 #s(literal 1/4 binary64) (.f64 b b)) (.f64 b (.f64 a (.f64 b a)))) (-.f64 (.f64 b #s(literal -1/2 binary64)) (*.f64 b a)))
(/.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))))
(/.f64 (*.f64 b (fma.f64 a a #s(literal -1/4 binary64))) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))))
(/.f64 (*.f64 (fma.f64 a a #s(literal -1/4 binary64)) b) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (-.f64 (.f64 (.f64 b (.f64 a (.f64 b a))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))) (.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64))) (.f64 #s(literal 1/4 binary64) (.f64 b b)))) (.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))))) (neg.f64 (neg.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (*.f64 b a)))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (-.f64 a #s(literal -1/2 binary64)))))) (neg.f64 (neg.f64 (.f64 b (-.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (-.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (.f64 b (.f64 a (.f64 b a))))) (neg.f64 (-.f64 (.f64 b #s(literal -1/2 binary64)) (*.f64 b a))))
(/.f64 (neg.f64 (.f64 b (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)))) (neg.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (neg.f64 (*.f64 b (fma.f64 a a #s(literal -1/4 binary64)))) (neg.f64 (+.f64 a #s(literal 1/2 binary64))))
(/.f64 (neg.f64 (.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) b)) (neg.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (neg.f64 (*.f64 (fma.f64 a a #s(literal -1/4 binary64)) b)) (neg.f64 (+.f64 a #s(literal 1/2 binary64))))
(pow.f64 (/.f64 (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.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 b (+.f64 a #s(literal -1/2 binary64)))
(*.f64 (+.f64 a #s(literal -1/2 binary64)) b)
(.f64 (fma.f64 (.f64 a (.f64 a a)) (.f64 b (.f64 b b)) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b #s(literal -1/2 binary64)) (-.f64 (.f64 b #s(literal -1/2 binary64)) (.f64 b a)) (.f64 b (.f64 a (.f64 b a))))))
(.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))))
(+.f64 x (-.f64 (+.f64 y z) (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))))
(+.f64 (+.f64 x y) (+.f64 (-.f64 z (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64))))
(+.f64 (+.f64 x y) (-.f64 z (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))))
(+.f64 z (-.f64 (+.f64 x y) (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))))
(+.f64 (+.f64 y (+.f64 x z)) (neg.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))))
(+.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (neg.f64 (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))
(+.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))))
(+.f64 (+.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (+.f64 x y)) (-.f64 z (*.f64 z (log.f64 t))))
(+.f64 (+.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (+.f64 y (+.f64 x z))) (*.f64 (log.f64 t) (neg.f64 z)))
(-.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64))))
(-.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))) (/.f64 (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))
(-.f64 (+.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (+.f64 y (+.f64 x z))) (*.f64 z (log.f64 t)))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x (-.f64 x y) (.f64 y y))) (+.f64 (-.f64 z (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x (-.f64 x y) (.f64 y y))) (-.f64 z (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (.f64 y (-.f64 y x)))) (+.f64 (-.f64 z (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (.f64 y (-.f64 y x)))) (-.f64 z (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (fma.f64 z (neg.f64 (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))
(fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(fma.f64 (.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) (+.f64 (-.f64 z (.f64 z (log.f64 t))) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))
(fma.f64 (.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) (-.f64 z (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (+.f64 (-.f64 z (.f64 z (log.f64 t))) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (-.f64 z (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))
(fma.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))
(fma.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))) (fma.f64 z (neg.f64 (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64))))
(fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z)))) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(/.f64 (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (-.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))))
(/.f64 (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))
(/.f64 (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (-.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))) (neg.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64))) #s(literal 3 binary64))) (fma.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)) (+.f64 (pow.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64))) #s(literal 2 binary64)) (.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (-.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (-.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))) (-.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))))
(/.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) #s(literal 2 binary64))) (+.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (.f64 (fma.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)) (fma.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))) (.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))) (.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (.f64 (fma.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)) (fma.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (fma.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 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))) (.f64 (fma.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)) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))) (.f64 (fma.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(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (fma.f64 z z (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (.f64 (+.f64 x y) z))) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) 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 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))) (.f64 (+.f64 x (-.f64 y z)) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) 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(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (+.f64 x (-.f64 y z)) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (.f64 (neg.f64 (fma.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)) (fma.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))) (.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (.f64 (neg.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))) (.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (.f64 (neg.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) 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 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) 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)) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (.f64 (neg.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) 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(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (neg.f64 (+.f64 x (-.f64 y z))) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (.f64 (fma.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)) (fma.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (fma.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 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))) (.f64 (fma.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)) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 y z) (.f64 (+.f64 y z) (+.f64 y z)))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))) (.f64 (fma.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(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (fma.f64 x x (-.f64 (.f64 (+.f64 y z) (+.f64 y z)) (.f64 x (+.f64 y z)))) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) 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)) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.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 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))) (.f64 (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.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)) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))) (.f64 (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.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(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) 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)) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (/.f64 (+.f64 x (-.f64 y z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))) (.f64 (/.f64 (+.f64 x (-.f64 y z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))) (.f64 (/.f64 (+.f64 x (-.f64 y z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (/.f64 (+.f64 x (-.f64 y z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) 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)) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) 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 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))) (.f64 (-.f64 x (+.f64 y z)) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (.f64 (-.f64 (.f64 x x) (.f64 (+.f64 y z) (+.f64 y z))) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) 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(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (-.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) 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)) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) 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 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))) (.f64 (-.f64 z (+.f64 x y)) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (.f64 (-.f64 (.f64 z z) (.f64 (+.f64 x y) (+.f64 x y))) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) 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(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (.f64 (-.f64 z (+.f64 x y)) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64))))) (.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))) (.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (-.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))) (neg.f64 (neg.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)) (+.f64 (pow.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64))) #s(literal 2 binary64)) (.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))))
(/.f64 (neg.f64 (-.f64 (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)))) (neg.f64 (-.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) #s(literal 2 binary64)))) (neg.f64 (+.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64))))))
(pow.f64 (/.f64 (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (-.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))) #s(literal -1 binary64))
(.f64 (fma.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (-.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)))))
(.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))))))
(+.f64 x y)
(+.f64 y x)
(-.f64 (/.f64 (.f64 y y) (-.f64 y x)) (/.f64 (.f64 x x) (-.f64 y x)))
(-.f64 (/.f64 (.f64 x x) (-.f64 x y)) (/.f64 (.f64 y y) (-.f64 x y)))
(/.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 x (-.f64 x y) (.f64 y y)))
(/.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 x x (.f64 y (-.f64 y x))))
(/.f64 (*.f64 (+.f64 x y) (-.f64 y x)) (-.f64 y x))
(/.f64 (*.f64 (+.f64 x y) (-.f64 x y)) (-.f64 x y))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 x (-.f64 x y) (.f64 y y))))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 x x (.f64 y (-.f64 y x)))))
(/.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 y x))) (neg.f64 (-.f64 y x)))
(/.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y))) (neg.f64 (-.f64 x y)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x x (.f64 y (-.f64 y x))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 y x) (*.f64 (+.f64 x y) (-.f64 y x))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 x y) (*.f64 (+.f64 x y) (-.f64 x y))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 x x (.f64 y (-.f64 y x))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 y x) (*.f64 (+.f64 x y) (-.f64 y x)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 x y) (*.f64 (+.f64 x y) (-.f64 x y)))))
(/.f64 (-.f64 (.f64 (.f64 y y) (-.f64 y x)) (.f64 (-.f64 y x) (.f64 x x))) (*.f64 (-.f64 y 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 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))) (neg.f64 (neg.f64 (fma.f64 x (-.f64 x y) (.f64 y y)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))) (neg.f64 (neg.f64 (fma.f64 x x (.f64 y (-.f64 y x))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 y x)))) (neg.f64 (neg.f64 (-.f64 y x))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y)))) (neg.f64 (neg.f64 (-.f64 x y))))
(pow.f64 (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 x x (.f64 y (-.f64 y x))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 y x) (*.f64 (+.f64 x y) (-.f64 y x))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 x y) (*.f64 (+.f64 x y) (-.f64 x y))) #s(literal -1 binary64))
(.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x (-.f64 x y) (*.f64 y y))))
(.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (*.f64 y (-.f64 y x)))))
(.f64 (.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)))
(.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)))
(+.f64 x (-.f64 (+.f64 y z) (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))
(+.f64 (+.f64 x y) (+.f64 (-.f64 z (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) (*.f64 b a))))
(+.f64 (+.f64 x y) (-.f64 z (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))
(+.f64 z (-.f64 (+.f64 x y) (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))
(+.f64 (+.f64 y (+.f64 x z)) (neg.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))
(+.f64 (+.f64 y (+.f64 x z)) (fma.f64 (log.f64 t) (neg.f64 z) #s(approx (* (- a 1/2) b) (*.f64 b a))))
(+.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(+.f64 #s(approx (* (- a 1/2) b) (*.f64 b a)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))))
(+.f64 (+.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (+.f64 x y)) (-.f64 z (.f64 z (log.f64 t))))
(+.f64 (+.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (+.f64 y (+.f64 x z))) (.f64 (log.f64 t) (neg.f64 z)))
(-.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a))))
(-.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (.f64 b a))))) (/.f64 (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (*.f64 b a))))))
(-.f64 (+.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (+.f64 y (+.f64 x z))) (.f64 z (log.f64 t)))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x (-.f64 x y) (.f64 y y))) (+.f64 (-.f64 z (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) (*.f64 b a))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x (-.f64 x y) (.f64 y y))) (-.f64 z (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (.f64 y (-.f64 y x)))) (+.f64 (-.f64 z (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) (*.f64 b a))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (.f64 y (-.f64 y x)))) (-.f64 z (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (fma.f64 (log.f64 t) (neg.f64 z) #s(approx (* (- a 1/2) b) (*.f64 b a))))
(fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 z (log.f64 t)) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z))) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))))) #s(approx ( (- a 1/2) b) (*.f64 b a)))
(fma.f64 (.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) (+.f64 (-.f64 z (.f64 z (log.f64 t))) #s(approx (* (- a 1/2) b) (*.f64 b a))))
(fma.f64 (.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) (-.f64 z (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (+.f64 (-.f64 z (.f64 z (log.f64 t))) #s(approx (* (- a 1/2) b) (*.f64 b a))))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (-.f64 z (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(fma.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))) (neg.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(fma.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))) (fma.f64 (log.f64 t) (neg.f64 z) #s(approx ( (- a 1/2) b) (*.f64 b a))))
(fma.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 z (log.f64 t) (+.f64 y (+.f64 x z)))) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (-.f64 #s(approx ( (- a 1/2) b) (*.f64 b a)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))))
(/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(approx (* (- a 1/2) b) (*.f64 b a))))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (*.f64 b a)))))
(/.f64 (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (-.f64 #s(approx ( (- a 1/2) b) (*.f64 b a)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(approx (* (- a 1/2) b) (*.f64 b a)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))) (neg.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (*.f64 b a))))))
(/.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (.f64 b a))) #s(literal 3 binary64))) (fma.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)) (+.f64 (pow.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) (.f64 b a))) #s(literal 2 binary64)) (.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (*.f64 b a))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (.f64 b a)))) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (*.f64 b a))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (*.f64 b a))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (.f64 b a)))) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))))
(/.f64 (-.f64 (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))) (-.f64 #s(approx ( (- a 1/2) b) (*.f64 b a)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))))
(/.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) (.f64 b a))) #s(literal 2 binary64))) (+.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(/.f64 (-.f64 (.f64 (fma.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)) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))))) (.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))))
(/.f64 (-.f64 (.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (.f64 b a)))) (.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (*.f64 b a)))))
(/.f64 (-.f64 (.f64 (fma.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)) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (fma.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 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))))) (.f64 (fma.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)) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))))
(/.f64 (-.f64 (.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (.f64 b a)))) (.f64 (fma.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(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (fma.f64 z z (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (.f64 (+.f64 x y) z))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(/.f64 (-.f64 (.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (+.f64 x (-.f64 y z)) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))))) (.f64 (+.f64 x (-.f64 y z)) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))))
(/.f64 (-.f64 (.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (.f64 b a)))) (.f64 (+.f64 x (-.f64 y z)) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (+.f64 x (-.f64 y z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(/.f64 (-.f64 (.f64 (neg.f64 (fma.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)) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))))) (.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))))
(/.f64 (-.f64 (.f64 (neg.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (.f64 b a)))) (.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (*.f64 b a)))))
(/.f64 (-.f64 (.f64 (neg.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (neg.f64 (+.f64 x (-.f64 y z))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))))) (.f64 (neg.f64 (+.f64 x (-.f64 y z))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))))
(/.f64 (-.f64 (.f64 (neg.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (.f64 b a)))) (.f64 (neg.f64 (+.f64 x (-.f64 y z))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (neg.f64 (+.f64 x (-.f64 y z))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(/.f64 (-.f64 (.f64 (fma.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)) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (fma.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 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))))) (.f64 (fma.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)) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))))
(/.f64 (-.f64 (.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 y z) (.f64 (+.f64 y z) (+.f64 y z)))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (.f64 b a)))) (.f64 (fma.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(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (fma.f64 x x (-.f64 (.f64 (+.f64 y z) (+.f64 y z)) (.f64 x (+.f64 y z)))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.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 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))))) (.f64 (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.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)) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (.f64 b a)))) (.f64 (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.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(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (/.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y))) (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z)))) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (/.f64 (+.f64 x (-.f64 y z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))))) (.f64 (/.f64 (+.f64 x (-.f64 y z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (.f64 b a)))) (.f64 (/.f64 (+.f64 x (-.f64 y z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (/.f64 (+.f64 x (-.f64 y z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 x (-.f64 y z)))) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (*.f64 b a)))))
(/.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)) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (-.f64 x (+.f64 y z)) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))))) (.f64 (-.f64 x (+.f64 y z)) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))))
(/.f64 (-.f64 (.f64 (-.f64 (.f64 x x) (.f64 (+.f64 y z) (+.f64 y z))) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (.f64 b a)))) (.f64 (-.f64 x (+.f64 y z)) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (-.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(/.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)) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (-.f64 z (+.f64 x y)) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))))) (.f64 (-.f64 z (+.f64 x y)) (+.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a)))))))
(/.f64 (-.f64 (.f64 (-.f64 (.f64 z z) (.f64 (+.f64 x y) (+.f64 x y))) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (.f64 b a)))) (.f64 (-.f64 z (+.f64 x y)) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (.f64 (-.f64 z (+.f64 x y)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(/.f64 (-.f64 (.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (.f64 b a))))) (.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (.f64 b a)))) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))) (.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (.f64 b a)))) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (*.f64 b a))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (-.f64 #s(approx ( (- a 1/2) b) (*.f64 b a)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))))) (neg.f64 (neg.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (*.f64 b a)))))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)))) (pow.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (.f64 b a))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z)) (+.f64 (pow.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) (.f64 b a))) #s(literal 2 binary64)) (.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) #s(approx ( (- a 1/2) b) (*.f64 b a))))))))
(/.f64 (neg.f64 (-.f64 (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)))) (neg.f64 (-.f64 #s(approx ( (- a 1/2) b) (*.f64 b a)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 y (+.f64 x z)) (+.f64 y (+.f64 x z))) (pow.f64 (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) (.f64 b a))) #s(literal 2 binary64)))) (neg.f64 (+.f64 (+.f64 y (+.f64 x z)) (-.f64 (.f64 z (log.f64 t)) #s(approx (* (- a 1/2) b) (*.f64 b a))))))
(pow.f64 (/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64))) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (*.f64 b a))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) (.f64 b a)))) (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (*.f64 b a))))) #s(literal -1 binary64))
(.f64 (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (-.f64 #s(approx ( (- a 1/2) b) (*.f64 b a)) (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z)))) (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)))))
(.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx ( (- a 1/2) b) (*.f64 b a))))))
(*.f64 z (log.f64 t))
(*.f64 (log.f64 t) z)
(log.f64 t)
(*.f64 b #s(literal -1/2 binary64))
(*.f64 #s(literal -1/2 binary64) b)
#s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))
#s(approx (* (- a 1/2) b) (*.f64 b a))

eval216.0ms (1.4%)

Memory: 24.9MiB live, 526.3MiB allocated
Compiler: Compiled 45 966 to 2 127 computations (95.4% saved)

prune295.0ms (1.9%)

Memory

-14.7MiB live, 537.9MiB allocated

Pruning

27 alts after pruning (26 fresh and 1 done)

	Pruned	Kept	Total
New	1 681	23	1 704
Fresh	12	3	15
Picked	4	1	5
Done	0	0	0
Total	1 697	27	1 724

Accuracy

100.0%

Counts

1 724 → 27

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	76.4%	(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
	43.6%	(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
	76.4%	(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
	23.5%	(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))
▶	99.7%	(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
	39.3%	(+.f64 (-.f64 #s(approx (+ (+ x y) z) (+.f64 z x)) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
	49.8%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
▶	70.0%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
	49.9%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 x (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x) x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
	31.7%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
	26.6%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (/.f64 #s(literal 1 binary64) b)))
	63.2%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
	36.0%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
	36.3%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
	43.9%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (.f64 y (-.f64 (+.f64 (/.f64 x y) (+.f64 #s(literal 1 binary64) (/.f64 z y))) (/.f64 (.f64 z (log.f64 t)) y)))) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
	48.2%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (.f64 x (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) x))))) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
	70.1%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ y x) (fma.f64 x (/.f64 y x) x))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
	14.1%	(.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
	24.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))
	61.4%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x)))
	83.4%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
	39.6%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
	71.9%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 a (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (+.f64 (+.f64 b (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 x a))) (+.f64 (/.f64 y a) (/.f64 z a))))))
▶	14.1%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
▶	20.2%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
	6.2%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64)))))
✓	27.2%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))

Compiler

Compiled 1 138 to 677 computations (40.5% saved)

simplify264.0ms (1.7%)

Memory

16.3MiB live, 503.5MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 19 expressions of interest:

New	Metric	Score
cost-diff	0	(-.f64 #s(literal 1 binary64) (log.f64 t))
cost-diff	0	(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))
cost-diff	0	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
cost-diff	0	(+.f64 z x)
cost-diff	0	(log1p.f64 (+.f64 z x))
cost-diff	0	(-.f64 y (log1p.f64 (+.f64 z x)))
cost-diff	0	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
cost-diff	0	(+.f64 x y)
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
cost-diff	0	(+.f64 a #s(literal -1/2 binary64))
cost-diff	0	(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
cost-diff	0	(+.f64 a #s(literal -1/2 binary64))
cost-diff	0	(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
cost-diff	0	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
cost-diff	0	(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))
cost-diff	0	(/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))))
cost-diff	128	(fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))
cost-diff	1408	(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))

Rules

12 152×	`lower-fma.f32`
12 144×	`lower-fma.f64`
2 544×	`lower-+.f32`
2 530×	`lower-+.f64`
2 038×	`lower--.f32`

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	41	277
0	64	271
1	120	271
2	254	261
3	799	261
4	2120	261
5	4990	261
6	7347	261
0	8018	261

Stop Event

1×	iter limit
1×	node limit
1×	iter limit

Calls

Call 1

Inputs
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
#s(literal 1 binary64)
(/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))
(+.f64 a #s(literal -1/2 binary64))
a
#s(literal -1/2 binary64)
b
(fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))
(log.f64 t)
t
(neg.f64 z)
z
(+.f64 x (+.f64 y z))
x
(+.f64 y z)
y
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
y
(+.f64 a #s(literal -1/2 binary64))
a
#s(literal -1/2 binary64)
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 a #s(literal -1/2 binary64))
a
#s(literal -1/2 binary64)
b
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
x
y
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
(-.f64 y (log1p.f64 (+.f64 z x)))
y
(log1p.f64 (+.f64 z x))
(+.f64 z x)
z
x
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
z
(-.f64 #s(literal 1 binary64) (log.f64 t))
#s(literal 1 binary64)
(log.f64 t)
t
y
#s(approx (* (- a 1/2) b) (*.f64 b a))
(*.f64 b a)
b
a

Outputs
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
(+.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b y))
#s(literal 1 binary64)
(/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))))
(/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b y)))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))
(+.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b y))
(+.f64 a #s(literal -1/2 binary64))
a
#s(literal -1/2 binary64)
b
(fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(log.f64 t)
t
(neg.f64 z)
z
(+.f64 x (+.f64 y z))
(+.f64 x (+.f64 z y))
x
(+.f64 y z)
(+.f64 z y)
y
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 #s(literal -1/2 binary64) (+.f64 a y)))
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(+.f64 #s(literal -1/2 binary64) (+.f64 a y))
y
(+.f64 a #s(literal -1/2 binary64))
a
#s(literal -1/2 binary64)
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 a #s(literal -1/2 binary64))
a
#s(literal -1/2 binary64)
b
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
x
y
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
(-.f64 y (log1p.f64 (+.f64 z x)))
y
(log1p.f64 (+.f64 z x))
(+.f64 z x)
z
x
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 a b)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
z
(-.f64 #s(literal 1 binary64) (log.f64 t))
#s(literal 1 binary64)
(log.f64 t)
t
y
#s(approx (* (- a 1/2) b) (*.f64 b a))
#s(approx (* (- a 1/2) b) (*.f64 a b))
(*.f64 b a)
(*.f64 a b)
b
a

localize188.0ms (1.2%)

Memory

-55.7MiB live, 236.7MiB allocated

Localize:

Found 19 expressions of interest:

New	Metric	Score
accuracy	0	(log.f64 t)
accuracy	0.0625	(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
accuracy	3.0559012340784713	#s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))
accuracy	15.876721423227519	#s(approx (* (- a 1/2) b) (*.f64 b a))
accuracy	0	(-.f64 y (log1p.f64 (+.f64 z x)))
accuracy	0	(+.f64 z x)
accuracy	0	(log1p.f64 (+.f64 z x))
accuracy	22.000589439257322	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
accuracy	0	(+.f64 x y)
accuracy	0	(+.f64 a #s(literal -1/2 binary64))
accuracy	0.00390625	(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
accuracy	13.529743194777314	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
accuracy	0	(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
accuracy	0	(+.f64 a #s(literal -1/2 binary64))
accuracy	23.49989664897641	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
accuracy	0.00390625	(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))
accuracy	0.06640625	(fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))
accuracy	0.0859375	(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
accuracy	1.010836837787994	(/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))))

Samples

62.0ms	124×	0	valid
35.0ms	132×	0	invalid

Compiler

Compiled 247 to 38 computations (84.6% saved)

Precisions

Click to see histograms. Total time spent on operations: 70.0ms

ival-log: 31.0ms (44.2% of total)

ival-mult: 15.0ms (21.4% of total)

ival-add: 13.0ms (18.5% of total)

ival-sub: 4.0ms (5.7% of total)

ival-div: 3.0ms (4.3% of total)

ival-log1p: 2.0ms (2.9% of total)

ival-neg: 1.0ms (1.4% of total)

ival-assert: 0.0ms (0% of total)

ival-true: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

series695.0ms (4.5%)

Memory

2.8MiB live, 1 425.5MiB allocated

Counts

20 → 876

Calls

Call 1

Inputs
#<alt (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))>
#<alt (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))>
#<alt (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))))>
#<alt (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))>
#<alt #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))>
#<alt (+.f64 y (+.f64 a #s(literal -1/2 binary64)))>
#<alt (+.f64 a #s(literal -1/2 binary64))>
#<alt (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))>
#<alt #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))>
#<alt (+.f64 x y)>
#<alt #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))>
#<alt (-.f64 y (log1p.f64 (+.f64 z x)))>
#<alt (log1p.f64 (+.f64 z x))>
#<alt (+.f64 z x)>
#<alt (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))>
#<alt #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))>
#<alt (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)>
#<alt (-.f64 #s(literal 1 binary64) (log.f64 t))>
#<alt #s(approx (* (- a 1/2) b) (*.f64 b a))>
#<alt (log.f64 t)>

Outputs
#<alt (- (+ y (* -1 (* z (log t)))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt a>
#<alt (* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))>
#<alt (* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))>
#<alt (* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (* b (- a 1/2))>
#<alt (* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))>
#<alt (* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))>
#<alt (* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))>
#<alt (+ 1 (+ y (* -1 (* z (log t)))))>
#<alt (+ 1 (+ y (* -1 (* z (log t)))))>
#<alt (+ 1 (+ y (* -1 (* z (log t)))))>
#<alt (+ 1 (+ y (* -1 (* z (log t)))))>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* z (log (/ 1 t))))) 1/2)>
#<alt (- (+ a (+ y (* z (log (/ 1 t))))) 1/2)>
#<alt (- (+ a (+ y (* z (log (/ 1 t))))) 1/2)>
#<alt (- (+ a (+ y (* z (log (/ 1 t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (+ 1/2 (+ a y))>
#<alt (+ 1/2 (+ a y))>
#<alt (+ 1/2 (+ a y))>
#<alt (+ 1/2 (+ a y))>
#<alt (- (+ y (/ t (log (* b (- a 1/2))))) 1)>
#<alt (- (+ y (/ t (log (* b (- a 1/2))))) 1)>
#<alt (- (+ y (/ t (log (* b (- a 1/2))))) 1)>
#<alt (- (+ y (/ t (log (* b (- a 1/2))))) 1)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a z) 1/2)>
#<alt (- (+ a (+ z (/ 1 x))) 1/2)>
#<alt (- (+ a (+ z (/ 1 x))) 1/2)>
#<alt (- (+ a (+ z (/ 1 x))) 1/2)>
#<alt (+ z (* b (- a 1/2)))>
#<alt (+ z (+ (* b (- a 1/2)) (/ 1 x)))>
#<alt (+ z (+ (* b (- a 1/2)) (/ 1 x)))>
#<alt (+ z (+ (* b (- a 1/2)) (/ 1 x)))>
#<alt (- (+ a (* -1 (* z (log t)))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a z) 1/2)>
#<alt (- (+ a (+ z (/ 1 y))) 1/2)>
#<alt (- (+ a (+ z (/ 1 y))) 1/2)>
#<alt (- (+ a (+ z (/ 1 y))) 1/2)>
#<alt (+ z (* b (- a 1/2)))>
#<alt (+ z (+ (* b (- a 1/2)) (/ 1 y)))>
#<alt (+ z (+ (* b (- a 1/2)) (/ 1 y)))>
#<alt (+ z (+ (* b (- a 1/2)) (/ 1 y)))>
#<alt (+ x (+ y (+ z (* -1 (* z (log t))))))>
#<alt (+ x (+ y (+ z (* -1 (* z (log t))))))>
#<alt (+ x (+ y (+ z (* -1 (* z (log t))))))>
#<alt (+ x (+ y (+ z (* -1 (* z (log t))))))>
#<alt (+ x (+ y (+ z (* z (log (/ 1 t))))))>
#<alt (+ x (+ y (+ z (* z (log (/ 1 t))))))>
#<alt (+ x (+ y (+ z (* z (log (/ 1 t))))))>
#<alt (+ x (+ y (+ z (* z (log (/ 1 t))))))>
#<alt (+ x (+ y (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))))>
#<alt (+ x (+ y (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))))>
#<alt (+ x (+ y (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))))>
#<alt (+ x (+ y (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))))>
#<alt (+ x y)>
#<alt (+ x (+ y (* z (+ 1 (* -1 (log t))))))>
#<alt (+ x (+ y (* z (+ 1 (* -1 (log t))))))>
#<alt (+ x (+ y (* z (+ 1 (* -1 (log t))))))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* z (+ 1 (+ (* -1 (log t)) (+ (/ x z) (/ y z)))))>
#<alt (* z (+ 1 (+ (* -1 (log t)) (+ (/ x z) (/ y z)))))>
#<alt (* z (+ 1 (+ (* -1 (log t)) (+ (/ x z) (/ y z)))))>
#<alt (* -1 (* z (- (log t) 1)))>
#<alt (* -1 (* z (- (+ (log t) (* -1 (/ (+ x y) z))) 1)))>
#<alt (* -1 (* z (- (+ (log t) (* -1 (/ (+ x y) z))) 1)))>
#<alt (* -1 (* z (- (+ (log t) (* -1 (/ (+ x y) z))) 1)))>
#<alt (+ y (+ z (* -1 (* z (log t)))))>
#<alt (+ x (+ y (+ z (* -1 (* z (log t))))))>
#<alt (+ x (+ y (+ z (* -1 (* z (log t))))))>
#<alt (+ x (+ y (+ z (* -1 (* z (log t))))))>
#<alt x>
#<alt (* x (+ 1 (+ (* -1 (/ (* z (log t)) x)) (+ (/ y x) (/ z x)))))>
#<alt (* x (+ 1 (+ (* -1 (/ (* z (log t)) x)) (+ (/ y x) (/ z x)))))>
#<alt (* x (+ 1 (+ (* -1 (/ (* z (log t)) x)) (+ (/ y x) (/ z x)))))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (+ y (+ z (* -1 (* z (log t))))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ y (+ z (* -1 (* z (log t))))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ y (+ z (* -1 (* z (log t))))) x)) 1)))>
#<alt (+ x (+ z (* -1 (* z (log t)))))>
#<alt (+ x (+ y (+ z (* -1 (* z (log t))))))>
#<alt (+ x (+ y (+ z (* -1 (* z (log t))))))>
#<alt (+ x (+ y (+ z (* -1 (* z (log t))))))>
#<alt y>
#<alt (* y (+ 1 (+ (* -1 (/ (* z (log t)) y)) (+ (/ x y) (/ z y)))))>
#<alt (* y (+ 1 (+ (* -1 (/ (* z (log t)) y)) (+ (/ x y) (/ z y)))))>
#<alt (* y (+ 1 (+ (* -1 (/ (* z (log t)) y)) (+ (/ x y) (/ z y)))))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (+ x (+ z (* -1 (* z (log t))))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (+ x (+ z (* -1 (* z (log t))))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (+ x (+ z (* -1 (* z (log t))))) y)) 1)))>
#<alt (+ x (+ z (* -1/2 b)))>
#<alt (+ x (+ z (+ (* -1/2 b) (* a b))))>
#<alt (+ x (+ z (+ (* -1/2 b) (* a b))))>
#<alt (+ x (+ z (+ (* -1/2 b) (* a b))))>
#<alt (* a b)>
#<alt (* a (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (/ z a)))))>
#<alt (* a (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (/ z a)))))>
#<alt (* a (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (/ z a)))))>
#<alt (/ 1 (* a b))>
#<alt (* -1 (/ (- (* -1 (/ (- (* 1/2 (/ 1 b)) (+ (* -1 (/ (* 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 (* z (log t))) (* -1/2 b))))) (- (* 1/2 (/ 1 b)) (+ (* -1 (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))))) (* a b))) (* 1/2 (/ 1 b))) (+ (* -1 (/ (* 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 (* z (log t))) (* -1/2 b))))) 2) (- (* 1/2 (/ 1 b)) (+ (* -1 (/ (* 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 (* z (log t))) (* -1/2 b))))) (- (* 1/2 (/ 1 b)) (+ (* -1 (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))))) b))) a)) (* 1/2 (/ 1 b))) (+ (* -1 (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) a)) (/ 1 b)) a))>
#<alt (+ x z)>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (* b (- a 1/2))>
#<alt (* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))>
#<alt (* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))>
#<alt (* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))>
#<alt (+ x z)>
#<alt (+ x (+ z (/ 1 b)))>
#<alt (+ x (+ z (/ 1 b)))>
#<alt (+ x (+ z (/ 1 b)))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (* b (- a 1/2)))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* z (+ 1 (+ (* -1 (log t)) (/ x z))))>
#<alt (* z (+ 1 (+ (* -1 (log t)) (/ x z))))>
#<alt (* z (+ 1 (+ (* -1 (log t)) (/ x z))))>
#<alt (- 1/2 (+ a x))>
#<alt (- (+ 1/2 (/ 1 z)) (+ a x))>
#<alt (- (+ 1/2 (/ 1 z)) (+ a x))>
#<alt (- (+ 1/2 (/ 1 z)) (+ a x))>
#<alt (+ z (* b (- a 1/2)))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ y (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))>
#<alt (+ y (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))>
#<alt (+ y (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))>
#<alt (+ y (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (/ 1 x)>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ z (* b (- a 1/2))))>
#<alt (+ x (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))>
#<alt (+ x (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))>
#<alt (+ x (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))>
#<alt (+ x (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))>
#<alt (/ 1 y)>
#<alt (/ 1 y)>
#<alt (/ 1 y)>
#<alt (/ 1 y)>
#<alt (- (+ y (* -1 (* z (log t)))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt a>
#<alt (* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))>
#<alt (* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))>
#<alt (* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))>
#<alt (* a b)>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))>
#<alt (* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (* b (- a 1/2))>
#<alt (* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))>
#<alt (* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))>
#<alt (* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))>
#<alt (+ 1 (+ y (* -1 (* z (log t)))))>
#<alt (+ 1 (+ y (* -1 (* z (log t)))))>
#<alt (+ 1 (+ y (* -1 (* z (log t)))))>
#<alt (+ 1 (+ y (* -1 (* z (log t)))))>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* z (log (/ 1 t))))) 1/2)>
#<alt (- (+ a (+ y (* z (log (/ 1 t))))) 1/2)>
#<alt (- (+ a (+ y (* z (log (/ 1 t))))) 1/2)>
#<alt (- (+ a (+ y (* z (log (/ 1 t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (+ 1/2 (+ a y))>
#<alt (+ 1/2 (+ a y))>
#<alt (+ 1/2 (+ a y))>
#<alt (+ 1/2 (+ a y))>
#<alt (- (+ y (/ t (log (* b (- a 1/2))))) 1)>
#<alt (- (+ y (/ t (log (* b (- a 1/2))))) 1)>
#<alt (- (+ y (/ t (log (* b (- a 1/2))))) 1)>
#<alt (- (+ y (/ t (log (* b (- a 1/2))))) 1)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a z) 1/2)>
#<alt (- (+ a (+ z (/ 1 x))) 1/2)>
#<alt (- (+ a (+ z (/ 1 x))) 1/2)>
#<alt (- (+ a (+ z (/ 1 x))) 1/2)>
#<alt (+ z (* b (- a 1/2)))>
#<alt (+ z (+ (* b (- a 1/2)) (/ 1 x)))>
#<alt (+ z (+ (* b (- a 1/2)) (/ 1 x)))>
#<alt (+ z (+ (* b (- a 1/2)) (/ 1 x)))>
#<alt (- (+ a (* -1 (* z (log t)))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a (+ y (* -1 (* z (log t))))) 1/2)>
#<alt (- (+ a z) 1/2)>
#<alt (- (+ a (+ z (/ 1 y))) 1/2)>
#<alt (- (+ a (+ z (/ 1 y))) 1/2)>
#<alt (- (+ a (+ z (/ 1 y))) 1/2)>
#<alt (+ z (* b (- a 1/2)))>
#<alt (+ z (+ (* b (- a 1/2)) (/ 1 y)))>
#<alt (+ z (+ (* b (- a 1/2)) (/ 1 y)))>
#<alt (+ z (+ (* b (- a 1/2)) (/ 1 y)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<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 (- y (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<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 (- y (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- a 1/2)>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a y) 1/2)>
#<alt y>
#<alt (* y (- (+ 1 (/ a y)) (* 1/2 (/ 1 y))))>
#<alt (* y (- (+ 1 (/ a y)) (* 1/2 (/ 1 y))))>
#<alt (* y (- (+ 1 (/ a y)) (* 1/2 (/ 1 y))))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (- a 1/2) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- a 1/2) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- a 1/2) y)) 1)))>
#<alt (- y 1/2)>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a y) 1/2)>
#<alt a>
#<alt (* a (- (+ 1 (/ y a)) (* 1/2 (/ 1 a))))>
#<alt (* a (- (+ 1 (/ y a)) (* 1/2 (/ 1 a))))>
#<alt (* a (- (+ 1 (/ y a)) (* 1/2 (/ 1 a))))>
#<alt a>
#<alt (* -1 (* a (- (* -1 (/ (- y 1/2) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (- y 1/2) a)) 1)))>
#<alt (* -1 (* a (- (* -1 (/ (- y 1/2) a)) 1)))>
#<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 (- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<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 (- y (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<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 (- y (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<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>
#<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 (- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<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 (- y (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<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 (- y (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (* -1 (log (+ 1 (+ x z))))>
#<alt (- y (log (+ 1 (+ x z))))>
#<alt (- y (log (+ 1 (+ x z))))>
#<alt (- y (log (+ 1 (+ x z))))>
#<alt y>
#<alt (* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))>
#<alt (* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))>
#<alt (* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))>
#<alt y>
#<alt (* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))>
#<alt (* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))>
#<alt (* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))>
#<alt (- y (log (+ 1 x)))>
#<alt (- (+ y (* -1 (/ z (+ 1 x)))) (log (+ 1 x)))>
#<alt (- (+ y (* z (- (* 1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x))))) (log (+ 1 x)))>
#<alt (- (+ y (* z (- (* z (+ (* -1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x))))) (log (+ 1 x)))>
#<alt (- y (* -1 (log (/ 1 z))))>
#<alt (- (+ y (* -1 (/ (+ 1 x) z))) (* -1 (log (/ 1 z))))>
#<alt (- (+ y (* 1/2 (/ (pow (+ 1 x) 2) (pow z 2)))) (+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z))))>
#<alt (- (+ y (* -1/3 (/ (pow (+ 1 x) 3) (pow z 3)))) (+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z)))))>
#<alt (* -1 z)>
#<alt (* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))>
#<alt (* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))>
#<alt (* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))>
#<alt (- y (log (+ 1 z)))>
#<alt (- (+ y (* -1 (/ x (+ 1 z)))) (log (+ 1 z)))>
#<alt (- (+ y (* x (- (* 1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z))))) (log (+ 1 z)))>
#<alt (- (+ y (* x (- (* x (+ (* -1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z))))) (log (+ 1 z)))>
#<alt (- y (* -1 (log (/ 1 x))))>
#<alt (- (+ y (* -1 (/ (+ 1 z) x))) (* -1 (log (/ 1 x))))>
#<alt (- (+ y (* 1/2 (/ (pow (+ 1 z) 2) (pow x 2)))) (+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x))))>
#<alt (- (+ y (* -1/3 (/ (pow (+ 1 z) 3) (pow x 3)))) (+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x)))))>
#<alt (* -1 x)>
#<alt (* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))>
#<alt (* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))>
#<alt (* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))>
#<alt (log (+ 1 x))>
#<alt (+ (log (+ 1 x)) (/ z (+ 1 x)))>
#<alt (+ (log (+ 1 x)) (* z (+ (* -1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x)))))>
#<alt (+ (log (+ 1 x)) (* z (+ (* z (- (* 1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x)))))>
#<alt (* -1 (log (/ 1 z)))>
#<alt (+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z)))>
#<alt (+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z))))>
#<alt (+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (* 1/3 (/ (pow (+ 1 x) 3) (pow z 3))) (+ (/ 1 z) (/ x z)))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))>
#<alt (log (+ 1 z))>
#<alt (+ (log (+ 1 z)) (/ x (+ 1 z)))>
#<alt (+ (log (+ 1 z)) (* x (+ (* -1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z)))))>
#<alt (+ (log (+ 1 z)) (* x (+ (* x (- (* 1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z)))))>
#<alt (* -1 (log (/ 1 x)))>
#<alt (+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x)))>
#<alt (+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x))))>
#<alt (+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (* 1/3 (/ (pow (+ 1 z) 3) (pow x 3))) (+ (/ 1 x) (/ z x)))))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))>
#<alt x>
#<alt (+ x z)>
#<alt (+ x z)>
#<alt (+ x z)>
#<alt z>
#<alt (* z (+ 1 (/ x z)))>
#<alt (* z (+ 1 (/ x z)))>
#<alt (* z (+ 1 (/ x z)))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ x z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ x z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ x z)) 1)))>
#<alt z>
#<alt (+ x z)>
#<alt (+ x z)>
#<alt (+ x z)>
#<alt x>
#<alt (* x (+ 1 (/ z x)))>
#<alt (* x (+ 1 (/ z x)))>
#<alt (* x (+ 1 (/ z x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ z x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ z x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ z x)) 1)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<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 (- y (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<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 (- y (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<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 (* 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 (/ y z)) (log t)))>
#<alt (* z (- (+ 1 (/ y z)) (log t)))>
#<alt (* z (- (+ 1 (/ y z)) (log t)))>
#<alt (/ 1 z)>
#<alt (/ 1 z)>
#<alt (/ 1 z)>
#<alt (/ 1 z)>
#<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 (/ 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 (log t))>
#<alt (- (+ 1 (/ 1 y)) (log t))>
#<alt (- (+ 1 (/ 1 y)) (log t))>
#<alt (- (+ 1 (/ 1 y)) (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 -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 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 (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt 1>
#<alt 1>
#<alt 1>
#<alt 1>
#<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

219 calls:

Time	Variable		Point	Expression
31.0ms	z	@	0	(+ (* (+ a -1/2) b) (- (+ (+ x y) z) (* z (log t))))
27.0ms	t	@	inf	(- (+ (+ x y) z) (* z (log t)))
22.0ms	b	@	0	(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
18.0ms	z	@	-inf	(/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z))))))
17.0ms	z	@	0	(- (+ (+ x y) z) (* z (log t)))

simplify693.0ms (4.5%)

Memory

4.5MiB live, 757.3MiB allocated

Algorithm

1×	egg-herbie

Rules

8 656×	`lower-fma.f64`
8 656×	`lower-fma.f32`
5 184×	`lower-+.f64`
5 184×	`lower-+.f32`
4 512×	`lower-*.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	694	12008
1	2124	11688
2	6386	11622
0	8006	10972

Stop Event

1×	iter limit
1×	node limit

Counts

876 → 839

Calls

Call 1

Inputs
(- (+ y (* -1 (* z (log t)))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
a
(* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))
(* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))
(* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))
(* a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(* b (- a 1/2))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(+ 1 (+ y (* -1 (* z (log t)))))
(+ 1 (+ y (* -1 (* z (log t)))))
(+ 1 (+ y (* -1 (* z (log t)))))
(+ 1 (+ y (* -1 (* z (log t)))))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(- (+ a y) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+ 1/2 (+ a y))
(+ 1/2 (+ a y))
(+ 1/2 (+ a y))
(+ 1/2 (+ a y))
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a z) 1/2)
(- (+ a (+ z (/ 1 x))) 1/2)
(- (+ a (+ z (/ 1 x))) 1/2)
(- (+ a (+ z (/ 1 x))) 1/2)
(+ z (* b (- a 1/2)))
(+ z (+ (* b (- a 1/2)) (/ 1 x)))
(+ z (+ (* b (- a 1/2)) (/ 1 x)))
(+ z (+ (* b (- a 1/2)) (/ 1 x)))
(- (+ a (* -1 (* z (log t)))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a z) 1/2)
(- (+ a (+ z (/ 1 y))) 1/2)
(- (+ a (+ z (/ 1 y))) 1/2)
(- (+ a (+ z (/ 1 y))) 1/2)
(+ z (* b (- a 1/2)))
(+ z (+ (* b (- a 1/2)) (/ 1 y)))
(+ z (+ (* b (- a 1/2)) (/ 1 y)))
(+ z (+ (* b (- a 1/2)) (/ 1 y)))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(+ x (+ y (+ z (* z (log (/ 1 t))))))
(+ x (+ y (+ z (* z (log (/ 1 t))))))
(+ x (+ y (+ z (* z (log (/ 1 t))))))
(+ x (+ y (+ z (* z (log (/ 1 t))))))
(+ x (+ y (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))))
(+ x (+ y (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))))
(+ x (+ y (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))))
(+ x (+ y (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))))
(+ x y)
(+ x (+ y (* z (+ 1 (* -1 (log t))))))
(+ x (+ y (* z (+ 1 (* -1 (log t))))))
(+ x (+ y (* z (+ 1 (* -1 (log t))))))
(* z (+ 1 (* -1 (log t))))
(* z (+ 1 (+ (* -1 (log t)) (+ (/ x z) (/ y z)))))
(* z (+ 1 (+ (* -1 (log t)) (+ (/ x z) (/ y z)))))
(* z (+ 1 (+ (* -1 (log t)) (+ (/ x z) (/ y z)))))
(* -1 (* z (- (log t) 1)))
(* -1 (* z (- (+ (log t) (* -1 (/ (+ x y) z))) 1)))
(* -1 (* z (- (+ (log t) (* -1 (/ (+ x y) z))) 1)))
(* -1 (* z (- (+ (log t) (* -1 (/ (+ x y) z))) 1)))
(+ y (+ z (* -1 (* z (log t)))))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(+ x (+ y (+ z (* -1 (* z (log t))))))
x
(* x (+ 1 (+ (* -1 (/ (* z (log t)) x)) (+ (/ y x) (/ z x)))))
(* x (+ 1 (+ (* -1 (/ (* z (log t)) x)) (+ (/ y x) (/ z x)))))
(* x (+ 1 (+ (* -1 (/ (* z (log t)) x)) (+ (/ y x) (/ z x)))))
x
(* -1 (* x (- (* -1 (/ (+ y (+ z (* -1 (* z (log t))))) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y (+ z (* -1 (* z (log t))))) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y (+ z (* -1 (* z (log t))))) x)) 1)))
(+ x (+ z (* -1 (* z (log t)))))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(+ x (+ y (+ z (* -1 (* z (log t))))))
y
(* y (+ 1 (+ (* -1 (/ (* z (log t)) y)) (+ (/ x y) (/ z y)))))
(* y (+ 1 (+ (* -1 (/ (* z (log t)) y)) (+ (/ x y) (/ z y)))))
(* y (+ 1 (+ (* -1 (/ (* z (log t)) y)) (+ (/ x y) (/ z y)))))
y
(* -1 (* y (- (* -1 (/ (+ x (+ z (* -1 (* z (log t))))) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* -1 (* z (log t))))) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* -1 (* z (log t))))) y)) 1)))
(+ x (+ z (* -1/2 b)))
(+ x (+ z (+ (* -1/2 b) (* a b))))
(+ x (+ z (+ (* -1/2 b) (* a b))))
(+ x (+ z (+ (* -1/2 b) (* a b))))
(* a b)
(* a (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (/ z a)))))
(* a (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (/ z a)))))
(* a (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (/ z a)))))
(/ 1 (* a b))
(* -1 (/ (- (* -1 (/ (- (* 1/2 (/ 1 b)) (+ (* -1 (/ (* 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 (* z (log t))) (* -1/2 b))))) (- (* 1/2 (/ 1 b)) (+ (* -1 (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))))) (* a b))) (* 1/2 (/ 1 b))) (+ (* -1 (/ (* 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 (* z (log t))) (* -1/2 b))))) 2) (- (* 1/2 (/ 1 b)) (+ (* -1 (/ (* 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 (* z (log t))) (* -1/2 b))))) (- (* 1/2 (/ 1 b)) (+ (* -1 (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))))) b))) a)) (* 1/2 (/ 1 b))) (+ (* -1 (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) a)) (/ 1 b)) a))
(+ x z)
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(* b (- a 1/2))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(+ x z)
(+ x (+ z (/ 1 b)))
(+ x (+ z (/ 1 b)))
(+ x (+ z (/ 1 b)))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (* b (- a 1/2)))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(* z (+ 1 (* -1 (log t))))
(* z (+ 1 (+ (* -1 (log t)) (/ x z))))
(* z (+ 1 (+ (* -1 (log t)) (/ x z))))
(* z (+ 1 (+ (* -1 (log t)) (/ x z))))
(- 1/2 (+ a x))
(- (+ 1/2 (/ 1 z)) (+ a x))
(- (+ 1/2 (/ 1 z)) (+ a x))
(- (+ 1/2 (/ 1 z)) (+ a x))
(+ z (* b (- a 1/2)))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ y (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+ y (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+ y (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+ y (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(/ 1 x)
(/ 1 x)
(/ 1 x)
(/ 1 x)
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ z (* b (- a 1/2))))
(+ x (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+ x (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+ x (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+ x (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(/ 1 y)
(/ 1 y)
(/ 1 y)
(/ 1 y)
(- (+ y (* -1 (* z (log t)))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
a
(* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))
(* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))
(* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))
(* a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(* b (- a 1/2))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(+ 1 (+ y (* -1 (* z (log t)))))
(+ 1 (+ y (* -1 (* z (log t)))))
(+ 1 (+ y (* -1 (* z (log t)))))
(+ 1 (+ y (* -1 (* z (log t)))))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(- (+ a y) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+ 1/2 (+ a y))
(+ 1/2 (+ a y))
(+ 1/2 (+ a y))
(+ 1/2 (+ a y))
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a z) 1/2)
(- (+ a (+ z (/ 1 x))) 1/2)
(- (+ a (+ z (/ 1 x))) 1/2)
(- (+ a (+ z (/ 1 x))) 1/2)
(+ z (* b (- a 1/2)))
(+ z (+ (* b (- a 1/2)) (/ 1 x)))
(+ z (+ (* b (- a 1/2)) (/ 1 x)))
(+ z (+ (* b (- a 1/2)) (/ 1 x)))
(- (+ a (* -1 (* z (log t)))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(- (+ a z) 1/2)
(- (+ a (+ z (/ 1 y))) 1/2)
(- (+ a (+ z (/ 1 y))) 1/2)
(- (+ a (+ z (/ 1 y))) 1/2)
(+ z (* b (- a 1/2)))
(+ z (+ (* b (- a 1/2)) (/ 1 y)))
(+ z (+ (* b (- a 1/2)) (/ 1 y)))
(+ z (+ (* b (- a 1/2)) (/ 1 y)))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a y) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* 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)))))
(- y (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(* 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))))
(- y (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- a 1/2)
(- (+ a y) 1/2)
(- (+ a y) 1/2)
(- (+ a y) 1/2)
y
(* y (- (+ 1 (/ a y)) (* 1/2 (/ 1 y))))
(* y (- (+ 1 (/ a y)) (* 1/2 (/ 1 y))))
(* y (- (+ 1 (/ a y)) (* 1/2 (/ 1 y))))
y
(* -1 (* y (- (* -1 (/ (- a 1/2) y)) 1)))
(* -1 (* y (- (* -1 (/ (- a 1/2) y)) 1)))
(* -1 (* y (- (* -1 (/ (- a 1/2) y)) 1)))
(- y 1/2)
(- (+ a y) 1/2)
(- (+ a y) 1/2)
(- (+ a y) 1/2)
a
(* a (- (+ 1 (/ y a)) (* 1/2 (/ 1 a))))
(* a (- (+ 1 (/ y a)) (* 1/2 (/ 1 a))))
(* a (- (+ 1 (/ y a)) (* 1/2 (/ 1 a))))
a
(* -1 (* a (- (* -1 (/ (- y 1/2) a)) 1)))
(* -1 (* a (- (* -1 (/ (- y 1/2) a)) 1)))
(* -1 (* a (- (* -1 (/ (- y 1/2) a)) 1)))
-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)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* 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)))))
(- y (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(* 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))))
(- y (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a y) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ 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
(+ 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)))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a y) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* 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)))))
(- y (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(* 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))))
(- y (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(* -1 (log (+ 1 (+ x z))))
(- y (log (+ 1 (+ x z))))
(- y (log (+ 1 (+ x z))))
(- y (log (+ 1 (+ x z))))
y
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
y
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(- y (log (+ 1 x)))
(- (+ y (* -1 (/ z (+ 1 x)))) (log (+ 1 x)))
(- (+ y (* z (- (* 1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x))))) (log (+ 1 x)))
(- (+ y (* z (- (* z (+ (* -1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x))))) (log (+ 1 x)))
(- y (* -1 (log (/ 1 z))))
(- (+ y (* -1 (/ (+ 1 x) z))) (* -1 (log (/ 1 z))))
(- (+ y (* 1/2 (/ (pow (+ 1 x) 2) (pow z 2)))) (+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z))))
(- (+ y (* -1/3 (/ (pow (+ 1 x) 3) (pow z 3)))) (+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z)))))
(* -1 z)
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(- y (log (+ 1 z)))
(- (+ y (* -1 (/ x (+ 1 z)))) (log (+ 1 z)))
(- (+ y (* x (- (* 1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z))))) (log (+ 1 z)))
(- (+ y (* x (- (* x (+ (* -1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z))))) (log (+ 1 z)))
(- y (* -1 (log (/ 1 x))))
(- (+ y (* -1 (/ (+ 1 z) x))) (* -1 (log (/ 1 x))))
(- (+ y (* 1/2 (/ (pow (+ 1 z) 2) (pow x 2)))) (+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x))))
(- (+ y (* -1/3 (/ (pow (+ 1 z) 3) (pow x 3)))) (+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x)))))
(* -1 x)
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(log (+ 1 x))
(+ (log (+ 1 x)) (/ z (+ 1 x)))
(+ (log (+ 1 x)) (* z (+ (* -1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x)))))
(+ (log (+ 1 x)) (* z (+ (* z (- (* 1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x)))))
(* -1 (log (/ 1 z)))
(+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z)))
(+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z))))
(+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (* 1/3 (/ (pow (+ 1 x) 3) (pow z 3))) (+ (/ 1 z) (/ x z)))))
z
(* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))
(log (+ 1 z))
(+ (log (+ 1 z)) (/ x (+ 1 z)))
(+ (log (+ 1 z)) (* x (+ (* -1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z)))))
(+ (log (+ 1 z)) (* x (+ (* x (- (* 1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z)))))
(* -1 (log (/ 1 x)))
(+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x)))
(+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x))))
(+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (* 1/3 (/ (pow (+ 1 z) 3) (pow x 3))) (+ (/ 1 x) (/ z x)))))
x
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
x
(+ x z)
(+ x z)
(+ x z)
z
(* z (+ 1 (/ x z)))
(* z (+ 1 (/ x z)))
(* z (+ 1 (/ x z)))
z
(* -1 (* z (- (* -1 (/ x z)) 1)))
(* -1 (* z (- (* -1 (/ x z)) 1)))
(* -1 (* z (- (* -1 (/ x z)) 1)))
z
(+ x z)
(+ x z)
(+ x z)
x
(* x (+ 1 (/ z x)))
(* x (+ 1 (/ z x)))
(* x (+ 1 (/ z x)))
x
(* -1 (* x (- (* -1 (/ z x)) 1)))
(* -1 (* x (- (* -1 (/ z x)) 1)))
(* -1 (* x (- (* -1 (/ z x)) 1)))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a y) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* 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)))))
(- y (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(* 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))))
(- y (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ 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))))))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* z (- 1 (log t)))
(* 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)))
(/ 1 z)
(/ 1 z)
(/ 1 z)
(/ 1 z)
(* 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)))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(/ 1 (* z (- 1 (log t))))
(- 1 (log t))
(- (+ 1 (/ 1 y)) (log t))
(- (+ 1 (/ 1 y)) (log t))
(- (+ 1 (/ 1 y)) (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)))))
-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 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)))))
(- a 1/2)
(- a 1/2)
(- a 1/2)
(- a 1/2)
(/ 1 b)
(/ 1 b)
(/ 1 b)
(/ 1 b)
1
1
1
1
(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 (* -1 (* z (log t)))) 1/2)
(+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal -1/2 binary64)))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
a
(* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (/.f64 (+.f64 y #s(literal -1/2 binary64)) a))))
(* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (/.f64 (+.f64 y #s(literal -1/2 binary64)) a))))
(* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (/.f64 (+.f64 y #s(literal -1/2 binary64)) a))))
(* a b)
(*.f64 a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(*.f64 b (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(*.f64 b (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(*.f64 b (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(+ 1 (+ y (* -1 (* z (log t)))))
(+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64)))
(+ 1 (+ y (* -1 (* z (log t)))))
(+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64)))
(+ 1 (+ y (* -1 (* z (log t)))))
(+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64)))
(+ 1 (+ y (* -1 (* z (log t)))))
(+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64)))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(+.f64 a (fma.f64 z (neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(+.f64 a (fma.f64 z (neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(+.f64 a (fma.f64 z (neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(+.f64 a (fma.f64 z (neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(+ 1/2 (+ a y))
(+.f64 y (+.f64 #s(literal 1/2 binary64) a))
(+ 1/2 (+ a y))
(+.f64 y (+.f64 #s(literal 1/2 binary64) a))
(+ 1/2 (+ a y))
(+.f64 y (+.f64 #s(literal 1/2 binary64) a))
(+ 1/2 (+ a y))
(+.f64 y (+.f64 #s(literal 1/2 binary64) a))
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(+.f64 (/.f64 t (log.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (+.f64 y #s(literal -1 binary64)))
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(+.f64 (/.f64 t (log.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (+.f64 y #s(literal -1 binary64)))
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(+.f64 (/.f64 t (log.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (+.f64 y #s(literal -1 binary64)))
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(+.f64 (/.f64 t (log.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (+.f64 y #s(literal -1 binary64)))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a z) 1/2)
(+.f64 z (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ z (/ 1 x))) 1/2)
(+.f64 a (+.f64 z (+.f64 (/.f64 #s(literal 1 binary64) x) #s(literal -1/2 binary64))))
(- (+ a (+ z (/ 1 x))) 1/2)
(+.f64 a (+.f64 z (+.f64 (/.f64 #s(literal 1 binary64) x) #s(literal -1/2 binary64))))
(- (+ a (+ z (/ 1 x))) 1/2)
(+.f64 a (+.f64 z (+.f64 (/.f64 #s(literal 1 binary64) x) #s(literal -1/2 binary64))))
(+ z (* b (- a 1/2)))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)
(+ z (+ (* b (- a 1/2)) (/ 1 x)))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) x)))
(+ z (+ (* b (- a 1/2)) (/ 1 x)))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) x)))
(+ z (+ (* b (- a 1/2)) (/ 1 x)))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) x)))
(- (+ a (* -1 (* z (log t)))) 1/2)
(+.f64 a (fma.f64 (log.f64 t) (neg.f64 z) #s(literal -1/2 binary64)))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a z) 1/2)
(+.f64 z (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ z (/ 1 y))) 1/2)
(+.f64 a (+.f64 (+.f64 z (/.f64 #s(literal 1 binary64) y)) #s(literal -1/2 binary64)))
(- (+ a (+ z (/ 1 y))) 1/2)
(+.f64 a (+.f64 (+.f64 z (/.f64 #s(literal 1 binary64) y)) #s(literal -1/2 binary64)))
(- (+ a (+ z (/ 1 y))) 1/2)
(+.f64 a (+.f64 (+.f64 z (/.f64 #s(literal 1 binary64) y)) #s(literal -1/2 binary64)))
(+ z (* b (- a 1/2)))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)
(+ z (+ (* b (- a 1/2)) (/ 1 y)))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) y)))
(+ z (+ (* b (- a 1/2)) (/ 1 y)))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) y)))
(+ z (+ (* b (- a 1/2)) (/ 1 y)))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) y)))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (+ z (* z (log (/ 1 t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (+ z (* z (log (/ 1 t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (+ z (* z (log (/ 1 t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (+ z (* z (log (/ 1 t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y x))
(+ x (+ y (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y x))
(+ x (+ y (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y x))
(+ x (+ y (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y x))
(+ x y)
(+.f64 y x)
(+ x (+ y (* z (+ 1 (* -1 (log t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (* z (+ 1 (* -1 (log t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (* z (+ 1 (* -1 (log t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(* z (+ 1 (* -1 (log t))))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (+ 1 (+ (* -1 (log t)) (+ (/ x z) (/ y z)))))
(fma.f64 z (+.f64 (/.f64 y z) (-.f64 (/.f64 x z) (log.f64 t))) z)
(* z (+ 1 (+ (* -1 (log t)) (+ (/ x z) (/ y z)))))
(fma.f64 z (+.f64 (/.f64 y z) (-.f64 (/.f64 x z) (log.f64 t))) z)
(* z (+ 1 (+ (* -1 (log t)) (+ (/ x z) (/ y z)))))
(fma.f64 z (+.f64 (/.f64 y z) (-.f64 (/.f64 x z) (log.f64 t))) z)
(* -1 (* z (- (log t) 1)))
(neg.f64 (fma.f64 z (log.f64 t) (neg.f64 z)))
(* -1 (* z (- (+ (log t) (* -1 (/ (+ x y) z))) 1)))
(*.f64 (-.f64 (+.f64 #s(literal -1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)) (neg.f64 z))
(* -1 (* z (- (+ (log t) (* -1 (/ (+ x y) z))) 1)))
(*.f64 (-.f64 (+.f64 #s(literal -1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)) (neg.f64 z))
(* -1 (* z (- (+ (log t) (* -1 (/ (+ x y) z))) 1)))
(*.f64 (-.f64 (+.f64 #s(literal -1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)) (neg.f64 z))
(+ y (+ z (* -1 (* z (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
(+ x (+ y (+ z (* -1 (* z (log t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
x
(* x (+ 1 (+ (* -1 (/ (* z (log t)) x)) (+ (/ y x) (/ z x)))))
(fma.f64 x (+.f64 (/.f64 y x) (-.f64 (/.f64 z x) (*.f64 z (/.f64 (log.f64 t) x)))) x)
(* x (+ 1 (+ (* -1 (/ (* z (log t)) x)) (+ (/ y x) (/ z x)))))
(fma.f64 x (+.f64 (/.f64 y x) (-.f64 (/.f64 z x) (*.f64 z (/.f64 (log.f64 t) x)))) x)
(* x (+ 1 (+ (* -1 (/ (* z (log t)) x)) (+ (/ y x) (/ z x)))))
(fma.f64 x (+.f64 (/.f64 y x) (-.f64 (/.f64 z x) (*.f64 z (/.f64 (log.f64 t) x)))) x)
x
(* -1 (* x (- (* -1 (/ (+ y (+ z (* -1 (* z (log t))))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (+ y (+ z (* -1 (* z (log t))))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (+ y (+ z (* -1 (* z (log t))))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(+ x (+ z (* -1 (* z (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)
(+ x (+ y (+ z (* -1 (* z (log t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (+ z (* -1 (* z (log t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
y
(* y (+ 1 (+ (* -1 (/ (* z (log t)) y)) (+ (/ x y) (/ z y)))))
(fma.f64 y (+.f64 (/.f64 z y) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) y) (/.f64 x y))) y)
(* y (+ 1 (+ (* -1 (/ (* z (log t)) y)) (+ (/ x y) (/ z y)))))
(fma.f64 y (+.f64 (/.f64 z y) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) y) (/.f64 x y))) y)
(* y (+ 1 (+ (* -1 (/ (* z (log t)) y)) (+ (/ x y) (/ z y)))))
(fma.f64 y (+.f64 (/.f64 z y) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) y) (/.f64 x y))) y)
y
(* -1 (* y (- (* -1 (/ (+ x (+ z (* -1 (* z (log t))))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* -1 (* z (log t))))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* -1 (* z (log t))))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(+ x (+ z (* -1/2 b)))
(+.f64 z (fma.f64 b #s(literal -1/2 binary64) x))
(+ x (+ z (+ (* -1/2 b) (* a b))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (+ (* -1/2 b) (* a b))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (+ (* -1/2 b) (* a b))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(* a b)
(*.f64 a b)
(* a (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (/ z a)))))
(*.f64 a (+.f64 (+.f64 (/.f64 x a) (/.f64 z a)) (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b)))
(* a (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (/ z a)))))
(*.f64 a (+.f64 (+.f64 (/.f64 x a) (/.f64 z a)) (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b)))
(* a (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (/ z a)))))
(*.f64 a (+.f64 (+.f64 (/.f64 x a) (/.f64 z a)) (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b)))
(/ 1 (* a b))
(/.f64 #s(literal 1 binary64) (*.f64 a b))
(* -1 (/ (- (* -1 (/ (- (* 1/2 (/ 1 b)) (+ (* -1 (/ (* 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 #s(literal -1 binary64) b) (/.f64 (-.f64 (-.f64 (/.f64 #s(literal 1/2 binary64) b) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) (.f64 b b)) (/.f64 x (.f64 b b)))) (+.f64 (/.f64 y (.f64 b b)) (/.f64 z (.f64 b b)))) a)) (neg.f64 a))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) (- (* 1/2 (/ 1 b)) (+ (* -1 (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))))) (* a b))) (* 1/2 (/ 1 b))) (+ (* -1 (/ (* 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 #s(literal -1 binary64) b) (/.f64 (-.f64 (-.f64 (-.f64 (/.f64 #s(literal 1/2 binary64) b) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) (.f64 b b)) (/.f64 x (.f64 b b)))) (+.f64 (/.f64 y (.f64 b b)) (/.f64 z (.f64 b b)))) (.f64 (-.f64 (-.f64 (/.f64 #s(literal 1/2 binary64) b) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) (.f64 b b)) (/.f64 x (.f64 b b)))) (+.f64 (/.f64 y (.f64 b b)) (/.f64 z (.f64 b b)))) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) (.f64 a b)))) a)) (neg.f64 a))
(* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (- (* -1 (/ (* (pow (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) 2) (- (* 1/2 (/ 1 b)) (+ (* -1 (/ (* 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 (* z (log t))) (* -1/2 b))))) (- (* 1/2 (/ 1 b)) (+ (* -1 (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2))))))) b))) a)) (* 1/2 (/ 1 b))) (+ (* -1 (/ (* z (log t)) (pow b 2))) (+ (/ x (pow b 2)) (+ (/ y (pow b 2)) (/ z (pow b 2)))))) a)) (/ 1 b)) a))
(neg.f64 (/.f64 (-.f64 (/.f64 #s(literal -1 binary64) b) (/.f64 (-.f64 (-.f64 (-.f64 (/.f64 #s(literal 1/2 binary64) b) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) (.f64 b b)) (/.f64 x (.f64 b b)))) (+.f64 (/.f64 y (.f64 b b)) (/.f64 z (.f64 b b)))) (/.f64 (-.f64 (.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) (/.f64 (-.f64 (-.f64 (/.f64 #s(literal 1/2 binary64) b) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) (.f64 b b)) (/.f64 x (.f64 b b)))) (+.f64 (/.f64 y (.f64 b b)) (/.f64 z (.f64 b b)))) b)) (.f64 (pow.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) #s(literal 2 binary64)) (/.f64 (-.f64 (-.f64 (/.f64 #s(literal 1/2 binary64) b) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) (.f64 b b)) (/.f64 x (.f64 b b)))) (+.f64 (/.f64 y (.f64 b b)) (/.f64 z (.f64 b b)))) (.f64 a (.f64 b b))))) a)) a)) a))
(+ x z)
(+.f64 z x)
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.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 (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(*.f64 b (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(*.f64 b (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(*.f64 b (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(+ x z)
(+.f64 z x)
(+ x (+ z (/ 1 b)))
(+.f64 z (+.f64 x (/.f64 #s(literal 1 binary64) b)))
(+ x (+ z (/ 1 b)))
(+.f64 z (+.f64 x (/.f64 #s(literal 1 binary64) b)))
(+ x (+ z (/ 1 b)))
(+.f64 z (+.f64 x (/.f64 #s(literal 1 binary64) b)))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (* b (- a 1/2)))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x)
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(* z (+ 1 (* -1 (log t))))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (+ 1 (+ (* -1 (log t)) (/ x z))))
(fma.f64 z (-.f64 (/.f64 x z) (log.f64 t)) z)
(* z (+ 1 (+ (* -1 (log t)) (/ x z))))
(fma.f64 z (-.f64 (/.f64 x z) (log.f64 t)) z)
(* z (+ 1 (+ (* -1 (log t)) (/ x z))))
(fma.f64 z (-.f64 (/.f64 x z) (log.f64 t)) z)
(- 1/2 (+ a x))
(-.f64 #s(literal 1/2 binary64) (+.f64 a x))
(- (+ 1/2 (/ 1 z)) (+ a x))
(-.f64 (-.f64 (+.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) z)) x) a)
(- (+ 1/2 (/ 1 z)) (+ a x))
(-.f64 (-.f64 (+.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) z)) x) a)
(- (+ 1/2 (/ 1 z)) (+ a x))
(-.f64 (-.f64 (+.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) z)) x) a)
(+ z (* b (- a 1/2)))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ y (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 z (log.f64 t))))
(+ y (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 z (log.f64 t))))
(+ y (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 z (log.f64 t))))
(+ y (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+.f64 y (-.f64 (/.f64 #s(literal 1 binary64) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (.f64 z (log.f64 t))))
(/ 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)
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ z (* b (- a 1/2))))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) x))
(+ x (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (fma.f64 (log.f64 t) (neg.f64 z) x))
(+ x (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (fma.f64 (log.f64 t) (neg.f64 z) x))
(+ x (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (fma.f64 (log.f64 t) (neg.f64 z) x))
(+ x (+ (* -1 (* z (log t))) (/ 1 (* b (- a 1/2)))))
(+.f64 (/.f64 #s(literal 1 binary64) (*.f64 b (+.f64 a #s(literal -1/2 binary64)))) (fma.f64 (log.f64 t) (neg.f64 z) x))
(/ 1 y)
(/.f64 #s(literal 1 binary64) y)
(/ 1 y)
(/.f64 #s(literal 1 binary64) y)
(/ 1 y)
(/.f64 #s(literal 1 binary64) y)
(/ 1 y)
(/.f64 #s(literal 1 binary64) y)
(- (+ y (* -1 (* z (log t)))) 1/2)
(+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal -1/2 binary64)))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
a
(* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (/.f64 (+.f64 y #s(literal -1/2 binary64)) a))))
(* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (/.f64 (+.f64 y #s(literal -1/2 binary64)) a))))
(* a (- (+ 1 (+ (* -1 (/ (* z (log t)) a)) (/ y a))) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (/.f64 (+.f64 y #s(literal -1/2 binary64)) a))))
(* a b)
(*.f64 a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (+ x (+ y (+ z (+ (* -1 (* z (log t))) (* -1/2 b))))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(* b (- a 1/2))
(*.f64 b (+.f64 a #s(literal -1/2 binary64)))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(*.f64 b (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(*.f64 b (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (* -1 (/ (* z (log t)) b)) (+ (/ x b) (+ (/ y b) (/ z b))))) 1/2))
(*.f64 b (+.f64 a (+.f64 (+.f64 (/.f64 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(+ 1 (+ y (* -1 (* z (log t)))))
(+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64)))
(+ 1 (+ y (* -1 (* z (log t)))))
(+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64)))
(+ 1 (+ y (* -1 (* z (log t)))))
(+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64)))
(+ 1 (+ y (* -1 (* z (log t)))))
(+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64)))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* z (log (/ 1 t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(+.f64 a (fma.f64 z (neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(+.f64 a (fma.f64 z (neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(+.f64 a (fma.f64 z (neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))) 1/2)
(+.f64 a (fma.f64 z (neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(+ 1/2 (+ a y))
(+.f64 y (+.f64 #s(literal 1/2 binary64) a))
(+ 1/2 (+ a y))
(+.f64 y (+.f64 #s(literal 1/2 binary64) a))
(+ 1/2 (+ a y))
(+.f64 y (+.f64 #s(literal 1/2 binary64) a))
(+ 1/2 (+ a y))
(+.f64 y (+.f64 #s(literal 1/2 binary64) a))
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(+.f64 (/.f64 t (log.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (+.f64 y #s(literal -1 binary64)))
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(+.f64 (/.f64 t (log.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (+.f64 y #s(literal -1 binary64)))
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(+.f64 (/.f64 t (log.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (+.f64 y #s(literal -1 binary64)))
(- (+ y (/ t (log (* b (- a 1/2))))) 1)
(+.f64 (/.f64 t (log.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))))) (+.f64 y #s(literal -1 binary64)))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a z) 1/2)
(+.f64 z (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ z (/ 1 x))) 1/2)
(+.f64 a (+.f64 z (+.f64 (/.f64 #s(literal 1 binary64) x) #s(literal -1/2 binary64))))
(- (+ a (+ z (/ 1 x))) 1/2)
(+.f64 a (+.f64 z (+.f64 (/.f64 #s(literal 1 binary64) x) #s(literal -1/2 binary64))))
(- (+ a (+ z (/ 1 x))) 1/2)
(+.f64 a (+.f64 z (+.f64 (/.f64 #s(literal 1 binary64) x) #s(literal -1/2 binary64))))
(+ z (* b (- a 1/2)))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)
(+ z (+ (* b (- a 1/2)) (/ 1 x)))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) x)))
(+ z (+ (* b (- a 1/2)) (/ 1 x)))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) x)))
(+ z (+ (* b (- a 1/2)) (/ 1 x)))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) x)))
(- (+ a (* -1 (* z (log t)))) 1/2)
(+.f64 a (fma.f64 (log.f64 t) (neg.f64 z) #s(literal -1/2 binary64)))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a (+ y (* -1 (* z (log t))))) 1/2)
(+.f64 (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) a)) #s(literal -1/2 binary64))
(- (+ a z) 1/2)
(+.f64 z (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ z (/ 1 y))) 1/2)
(+.f64 a (+.f64 (+.f64 z (/.f64 #s(literal 1 binary64) y)) #s(literal -1/2 binary64)))
(- (+ a (+ z (/ 1 y))) 1/2)
(+.f64 a (+.f64 (+.f64 z (/.f64 #s(literal 1 binary64) y)) #s(literal -1/2 binary64)))
(- (+ a (+ z (/ 1 y))) 1/2)
(+.f64 a (+.f64 (+.f64 z (/.f64 #s(literal 1 binary64) y)) #s(literal -1/2 binary64)))
(+ z (* b (- a 1/2)))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)
(+ z (+ (* b (- a 1/2)) (/ 1 y)))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) y)))
(+ z (+ (* b (- a 1/2)) (/ 1 y)))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) y)))
(+ z (+ (* b (- a 1/2)) (/ 1 y)))
(+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) y)))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 x (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 #s(literal 1/2 binary64) (/.f64 x (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(-.f64 (-.f64 (+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))))) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 x (.f64 x x)) (.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))) (*.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))))) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(-.f64 (-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (/.f64 #s(literal 1/3 binary64) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 y (*.f64 y y))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (-.f64 y (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (-.f64 y (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (.f64 z (*.f64 z z)))))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))) (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))) (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))) (+.f64 a #s(literal -1/2 binary64)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 b #s(literal -1/2 binary64) y) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 #s(literal 1/2 binary64) (/.f64 a (*.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (fma.f64 #s(literal -1/3 binary64) (/.f64 a (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(* a b)
(*.f64 a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(*.f64 a (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (-.f64 b (/.f64 (log.f64 a) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (-.f64 (+.f64 (+.f64 (/.f64 y a) (/.f64 #s(literal 1/2 binary64) (.f64 a a))) (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b)) (/.f64 (log.f64 a) a)) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (.f64 a a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (+.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (/.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (.f64 a (.f64 a a)))) (+.f64 (/.f64 y a) (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 #s(literal 1/2 binary64) (.f64 a a))))) (-.f64 b (/.f64 (log.f64 a) a))) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (*.f64 a a)))))
(* a b)
(*.f64 a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(- y (log (- (+ a (+ x z)) 1/2)))
(-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(* 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 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #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 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #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 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- a 1/2)
(+.f64 a #s(literal -1/2 binary64))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
y
(* y (- (+ 1 (/ a y)) (* 1/2 (/ 1 y))))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal -1/2 binary64)) y)))
(* y (- (+ 1 (/ a y)) (* 1/2 (/ 1 y))))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal -1/2 binary64)) y)))
(* y (- (+ 1 (/ a y)) (* 1/2 (/ 1 y))))
(*.f64 y (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal -1/2 binary64)) y)))
y
(* -1 (* y (- (* -1 (/ (- a 1/2) y)) 1)))
(neg.f64 (*.f64 y (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 a #s(literal -1/2 binary64)) y))))
(* -1 (* y (- (* -1 (/ (- a 1/2) y)) 1)))
(neg.f64 (*.f64 y (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 a #s(literal -1/2 binary64)) y))))
(* -1 (* y (- (* -1 (/ (- a 1/2) y)) 1)))
(neg.f64 (*.f64 y (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 a #s(literal -1/2 binary64)) y))))
(- y 1/2)
(+.f64 y #s(literal -1/2 binary64))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
a
(* a (- (+ 1 (/ y a)) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(literal -1/2 binary64)) a)))
(* a (- (+ 1 (/ y a)) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(literal -1/2 binary64)) a)))
(* a (- (+ 1 (/ y a)) (* 1/2 (/ 1 a))))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(literal -1/2 binary64)) a)))
a
(* -1 (* a (- (* -1 (/ (- y 1/2) a)) 1)))
(neg.f64 (*.f64 a (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 y #s(literal -1/2 binary64)) a))))
(* -1 (* a (- (* -1 (/ (- y 1/2) a)) 1)))
(neg.f64 (*.f64 a (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 y #s(literal -1/2 binary64)) a))))
(* -1 (* a (- (* -1 (/ (- y 1/2) a)) 1)))
(neg.f64 (*.f64 a (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 y #s(literal -1/2 binary64)) a))))
-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)))
(neg.f64 (fma.f64 a (/.f64 #s(literal 1/2 binary64) a) (neg.f64 a)))
(* -1 (* a (- (* 1/2 (/ 1 a)) 1)))
(neg.f64 (fma.f64 a (/.f64 #s(literal 1/2 binary64) a) (neg.f64 a)))
(* -1 (* a (- (* 1/2 (/ 1 a)) 1)))
(neg.f64 (fma.f64 a (/.f64 #s(literal 1/2 binary64) a) (neg.f64 a)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 b #s(literal -1/2 binary64) y) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 #s(literal 1/2 binary64) (/.f64 a (*.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (fma.f64 #s(literal -1/3 binary64) (/.f64 a (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(* a b)
(*.f64 a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(*.f64 a (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (-.f64 b (/.f64 (log.f64 a) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (-.f64 (+.f64 (+.f64 (/.f64 y a) (/.f64 #s(literal 1/2 binary64) (.f64 a a))) (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b)) (/.f64 (log.f64 a) a)) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (.f64 a a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (+.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (/.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (.f64 a (.f64 a a)))) (+.f64 (/.f64 y a) (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 #s(literal 1/2 binary64) (.f64 a a))))) (-.f64 b (/.f64 (log.f64 a) a))) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (*.f64 a a)))))
(* a b)
(*.f64 a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(- y (log (- (+ a (+ x z)) 1/2)))
(-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(* 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 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #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 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #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 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 x (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 #s(literal 1/2 binary64) (/.f64 x (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(-.f64 (-.f64 (+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))))) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 x (.f64 x x)) (.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))) (*.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))))) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(-.f64 (-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (/.f64 #s(literal 1/3 binary64) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 y (*.f64 y y))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (-.f64 y (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (-.f64 y (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (.f64 z (*.f64 z z)))))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))) (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))) (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))) (+.f64 a #s(literal -1/2 binary64)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
x
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(fma.f64 x (+.f64 (/.f64 y x) (-.f64 (/.f64 z x) (*.f64 z (/.f64 (log.f64 t) x)))) x)
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(fma.f64 x (+.f64 (/.f64 y x) (-.f64 (/.f64 z x) (*.f64 z (/.f64 (log.f64 t) x)))) x)
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(fma.f64 x (+.f64 (/.f64 y x) (-.f64 (/.f64 z x) (*.f64 z (/.f64 (log.f64 t) x)))) x)
x
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(- (+ x z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
y
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(fma.f64 y (+.f64 (/.f64 z y) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) y) (/.f64 x y))) y)
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(fma.f64 y (+.f64 (/.f64 z y) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) y) (/.f64 x y))) y)
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(fma.f64 y (+.f64 (/.f64 z y) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) y) (/.f64 x y))) y)
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(+ x y)
(+.f64 y x)
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(fma.f64 z (+.f64 (/.f64 y z) (-.f64 (/.f64 x z) (log.f64 t))) z)
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(fma.f64 z (+.f64 (/.f64 y z) (-.f64 (/.f64 x z) (log.f64 t))) z)
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(fma.f64 z (+.f64 (/.f64 y z) (-.f64 (/.f64 x z) (log.f64 t))) z)
(* z (+ 1 (* -1 (log t))))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 #s(literal -1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 #s(literal -1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 #s(literal -1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)) (neg.f64 z))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y x))
y
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
x
(* x (+ 1 (/ y x)))
(fma.f64 x (/.f64 y x) x)
(* x (+ 1 (/ y x)))
(fma.f64 x (/.f64 y x) x)
(* x (+ 1 (/ y x)))
(fma.f64 x (/.f64 y x) x)
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 y x))))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 y x))))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(neg.f64 (*.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)))
(fma.f64 y (/.f64 x y) y)
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 x y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 x y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 x y)) (neg.f64 y))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 x (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 #s(literal 1/2 binary64) (/.f64 x (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(-.f64 (-.f64 (+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))))) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 x (.f64 x x)) (.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))) (*.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))))) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(-.f64 (-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (/.f64 #s(literal 1/3 binary64) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 y (*.f64 y y))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (-.f64 y (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (-.f64 y (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (.f64 z (*.f64 z z)))))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))) (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))) (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))) (+.f64 a #s(literal -1/2 binary64)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 b #s(literal -1/2 binary64) y) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 #s(literal 1/2 binary64) (/.f64 a (*.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (fma.f64 #s(literal -1/3 binary64) (/.f64 a (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(* a b)
(*.f64 a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(*.f64 a (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (-.f64 b (/.f64 (log.f64 a) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (-.f64 (+.f64 (+.f64 (/.f64 y a) (/.f64 #s(literal 1/2 binary64) (.f64 a a))) (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b)) (/.f64 (log.f64 a) a)) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (.f64 a a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (+.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (/.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (.f64 a (.f64 a a)))) (+.f64 (/.f64 y a) (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 #s(literal 1/2 binary64) (.f64 a a))))) (-.f64 b (/.f64 (log.f64 a) a))) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (*.f64 a a)))))
(* a b)
(*.f64 a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(- y (log (- (+ a (+ x z)) 1/2)))
(-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(* 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 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #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 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #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 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(* -1 (log (+ 1 (+ x z))))
(neg.f64 (log1p.f64 (+.f64 z x)))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 z x)))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 z x)))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 z x)))
y
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(fma.f64 y (/.f64 (log1p.f64 (+.f64 z x)) (neg.f64 y)) y)
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(fma.f64 y (/.f64 (log1p.f64 (+.f64 z x)) (neg.f64 y)) y)
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(fma.f64 y (/.f64 (log1p.f64 (+.f64 z x)) (neg.f64 y)) y)
y
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(neg.f64 (fma.f64 y (/.f64 (log1p.f64 (+.f64 z x)) y) (neg.f64 y)))
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(neg.f64 (fma.f64 y (/.f64 (log1p.f64 (+.f64 z x)) y) (neg.f64 y)))
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(neg.f64 (fma.f64 y (/.f64 (log1p.f64 (+.f64 z x)) y) (neg.f64 y)))
(- y (log (+ 1 x)))
(-.f64 y (log1p.f64 x))
(- (+ y (* -1 (/ z (+ 1 x)))) (log (+ 1 x)))
(+.f64 (/.f64 z (-.f64 #s(literal -1 binary64) x)) (-.f64 y (log1p.f64 x)))
(- (+ y (* z (- (* 1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x))))) (log (+ 1 x)))
(fma.f64 z (fma.f64 z (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal 1 binary64) x) (+.f64 #s(literal 1 binary64) x))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal 1 binary64) x))) (-.f64 y (log1p.f64 x)))
(- (+ y (* z (- (* z (+ (* -1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x))))) (log (+ 1 x)))
(-.f64 (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 #s(literal 1 binary64) x) (.f64 (+.f64 #s(literal 1 binary64) x) (+.f64 #s(literal 1 binary64) x)))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 #s(literal 1 binary64) x) (+.f64 #s(literal 1 binary64) x)))) (/.f64 #s(literal -1 binary64) (+.f64 #s(literal 1 binary64) x))) y) (log1p.f64 x))
(- y (* -1 (log (/ 1 z))))
(-.f64 y (log.f64 z))
(- (+ y (* -1 (/ (+ 1 x) z))) (* -1 (log (/ 1 z))))
(+.f64 (/.f64 (-.f64 #s(literal -1 binary64) x) z) (-.f64 y (log.f64 z)))
(- (+ y (* 1/2 (/ (pow (+ 1 x) 2) (pow z 2)))) (+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (+.f64 #s(literal 1 binary64) x) (+.f64 #s(literal 1 binary64) x)) (.f64 z z)) (-.f64 y (+.f64 (/.f64 x z) (+.f64 (/.f64 #s(literal 1 binary64) z) (log.f64 z)))))
(- (+ y (* -1/3 (/ (pow (+ 1 x) 3) (pow z 3)))) (+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z)))))
(-.f64 (fma.f64 #s(literal -1/3 binary64) (/.f64 (.f64 (+.f64 #s(literal 1 binary64) x) (.f64 (+.f64 #s(literal 1 binary64) x) (+.f64 #s(literal 1 binary64) x))) (.f64 z (.f64 z z))) y) (+.f64 (log.f64 z) (+.f64 (/.f64 x z) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 #s(literal 1 binary64) x) (+.f64 #s(literal 1 binary64) x)) (.f64 z z)) (/.f64 #s(literal 1 binary64) z)))))
(* -1 z)
(neg.f64 z)
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(neg.f64 (fma.f64 (neg.f64 z) (/.f64 (+.f64 y (-.f64 #s(literal -1 binary64) x)) z) z))
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(neg.f64 (fma.f64 (neg.f64 z) (/.f64 (+.f64 y (-.f64 #s(literal -1 binary64) x)) z) z))
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(neg.f64 (fma.f64 (neg.f64 z) (/.f64 (+.f64 y (-.f64 #s(literal -1 binary64) x)) z) z))
(- y (log (+ 1 z)))
(-.f64 y (log1p.f64 z))
(- (+ y (* -1 (/ x (+ 1 z)))) (log (+ 1 z)))
(-.f64 (+.f64 y (/.f64 x (-.f64 #s(literal -1 binary64) z))) (log1p.f64 z))
(- (+ y (* x (- (* 1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z))))) (log (+ 1 z)))
(fma.f64 x (fma.f64 #s(literal 1/2 binary64) (/.f64 x (*.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (/.f64 #s(literal -1 binary64) (+.f64 z #s(literal 1 binary64)))) (-.f64 y (log1p.f64 z)))
(- (+ y (* x (- (* x (+ (* -1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z))))) (log (+ 1 z)))
(fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z #s(literal 1 binary64)))) (-.f64 y (log1p.f64 z)))
(- y (* -1 (log (/ 1 x))))
(-.f64 y (log.f64 x))
(- (+ y (* -1 (/ (+ 1 z) x))) (* -1 (log (/ 1 x))))
(+.f64 (/.f64 (-.f64 #s(literal -1 binary64) z) x) (-.f64 y (log.f64 x)))
(- (+ y (* 1/2 (/ (pow (+ 1 z) 2) (pow x 2)))) (+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x x)) y) (+.f64 (/.f64 z x) (+.f64 (/.f64 #s(literal 1 binary64) x) (log.f64 x))))
(- (+ y (* -1/3 (/ (pow (+ 1 z) 3) (pow x 3)))) (+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x)))))
(-.f64 (fma.f64 #s(literal -1/3 binary64) (.f64 (+.f64 z #s(literal 1 binary64)) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x (.f64 x x)))) y) (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 z x)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x x)) (log.f64 x))))
(* -1 x)
(neg.f64 x)
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(*.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 y (+.f64 z #s(literal 1 binary64))) x)))
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(*.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 y (+.f64 z #s(literal 1 binary64))) x)))
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(*.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 y (+.f64 z #s(literal 1 binary64))) x)))
(log (+ 1 x))
(log1p.f64 x)
(+ (log (+ 1 x)) (/ z (+ 1 x)))
(+.f64 (log1p.f64 x) (/.f64 z (+.f64 #s(literal 1 binary64) x)))
(+ (log (+ 1 x)) (* z (+ (* -1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x)))))
(fma.f64 z (fma.f64 #s(literal -1/2 binary64) (/.f64 z (*.f64 (+.f64 #s(literal 1 binary64) x) (+.f64 #s(literal 1 binary64) x))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) x))) (log1p.f64 x))
(+ (log (+ 1 x)) (* z (+ (* z (- (* 1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x)))))
(fma.f64 z (fma.f64 z (fma.f64 #s(literal 1/3 binary64) (/.f64 z (.f64 (+.f64 #s(literal 1 binary64) x) (.f64 (+.f64 #s(literal 1 binary64) x) (+.f64 #s(literal 1 binary64) x)))) (/.f64 #s(literal -1/2 binary64) (*.f64 (+.f64 #s(literal 1 binary64) x) (+.f64 #s(literal 1 binary64) x)))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) x))) (log1p.f64 x))
(* -1 (log (/ 1 z)))
(log.f64 z)
(+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z)))
(+.f64 (/.f64 x z) (+.f64 (/.f64 #s(literal 1 binary64) z) (log.f64 z)))
(+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z))))
(+.f64 (log.f64 z) (+.f64 (/.f64 x z) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 #s(literal 1 binary64) x) (+.f64 #s(literal 1 binary64) x)) (.f64 z z)) (/.f64 #s(literal 1 binary64) z))))
(+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (* 1/3 (/ (pow (+ 1 x) 3) (pow z 3))) (+ (/ 1 z) (/ x z)))))
(+.f64 (fma.f64 #s(literal 1/3 binary64) (/.f64 (.f64 (+.f64 #s(literal 1 binary64) x) (.f64 (+.f64 #s(literal 1 binary64) x) (+.f64 #s(literal 1 binary64) x))) (.f64 z (.f64 z z))) (+.f64 (/.f64 x z) (/.f64 #s(literal 1 binary64) z))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 #s(literal 1 binary64) x) (+.f64 #s(literal 1 binary64) x)) (.f64 z z)) (log.f64 z)))
z
(* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))
(neg.f64 (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))
(neg.f64 (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))
(neg.f64 (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z)))
(log (+ 1 z))
(log1p.f64 z)
(+ (log (+ 1 z)) (/ x (+ 1 z)))
(+.f64 (log1p.f64 z) (/.f64 x (+.f64 z #s(literal 1 binary64))))
(+ (log (+ 1 z)) (* x (+ (* -1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z)))))
(fma.f64 x (fma.f64 #s(literal -1/2 binary64) (/.f64 x (*.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 z #s(literal 1 binary64)))) (log1p.f64 z))
(+ (log (+ 1 z)) (* x (+ (* x (- (* 1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z)))))
(fma.f64 x (fma.f64 x (fma.f64 #s(literal 1/3 binary64) (/.f64 x (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))))) (/.f64 #s(literal -1/2 binary64) (*.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))))) (/.f64 #s(literal 1 binary64) (+.f64 z #s(literal 1 binary64)))) (log1p.f64 z))
(* -1 (log (/ 1 x)))
(log.f64 x)
(+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x)))
(+.f64 (/.f64 z x) (+.f64 (/.f64 #s(literal 1 binary64) x) (log.f64 x)))
(+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x))))
(+.f64 (+.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 z x)) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x x)) (log.f64 x)))
(+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (* 1/3 (/ (pow (+ 1 z) 3) (pow x 3))) (+ (/ 1 x) (/ z x)))))
(+.f64 (fma.f64 #s(literal 1/3 binary64) (.f64 (+.f64 z #s(literal 1 binary64)) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x (.f64 x x)))) (+.f64 (/.f64 #s(literal 1 binary64) x) (/.f64 z x))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x x)) (log.f64 x)))
x
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))
x
(+ x z)
(+.f64 z x)
(+ x z)
(+.f64 z x)
(+ x z)
(+.f64 z x)
z
(* z (+ 1 (/ x z)))
(fma.f64 z (/.f64 x z) z)
(* z (+ 1 (/ x z)))
(fma.f64 z (/.f64 x z) z)
(* z (+ 1 (/ x z)))
(fma.f64 z (/.f64 x z) z)
z
(* -1 (* z (- (* -1 (/ x z)) 1)))
(neg.f64 (*.f64 z (-.f64 #s(literal -1 binary64) (/.f64 x z))))
(* -1 (* z (- (* -1 (/ x z)) 1)))
(neg.f64 (*.f64 z (-.f64 #s(literal -1 binary64) (/.f64 x z))))
(* -1 (* z (- (* -1 (/ x z)) 1)))
(neg.f64 (*.f64 z (-.f64 #s(literal -1 binary64) (/.f64 x z))))
z
(+ x z)
(+.f64 z x)
(+ x z)
(+.f64 z x)
(+ x z)
(+.f64 z x)
x
(* x (+ 1 (/ z x)))
(fma.f64 x (/.f64 z x) x)
(* x (+ 1 (/ z x)))
(fma.f64 x (/.f64 z x) x)
(* x (+ 1 (/ z x)))
(fma.f64 x (/.f64 z x) x)
x
(* -1 (* x (- (* -1 (/ z x)) 1)))
(*.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 z x)))
(* -1 (* x (- (* -1 (/ z x)) 1)))
(*.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 z x)))
(* -1 (* x (- (* -1 (/ z x)) 1)))
(*.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 z x)))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 x (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 #s(literal 1/2 binary64) (/.f64 x (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(-.f64 (-.f64 (+.f64 z (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))))) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 x (.f64 x x)) (.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))) (*.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))))) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(-.f64 (-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (/.f64 #s(literal 1/3 binary64) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 y (*.f64 y y))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (-.f64 y (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (-.f64 y (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (.f64 z (*.f64 z z)))))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))) (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))) (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (+.f64 y (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64)))))) (+.f64 a #s(literal -1/2 binary64)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 b #s(literal -1/2 binary64) y) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 #s(literal 1/2 binary64) (/.f64 a (*.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (fma.f64 #s(literal -1/3 binary64) (/.f64 a (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))
(* a b)
(*.f64 a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(*.f64 a (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (-.f64 b (/.f64 (log.f64 a) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (-.f64 (+.f64 (+.f64 (/.f64 y a) (/.f64 #s(literal 1/2 binary64) (.f64 a a))) (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b)) (/.f64 (log.f64 a) a)) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (.f64 a a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (+.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (/.f64 (+.f64 z (+.f64 x #s(literal -1/2 binary64))) (.f64 a (.f64 a a)))) (+.f64 (/.f64 y a) (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 #s(literal 1/2 binary64) (.f64 a a))))) (-.f64 b (/.f64 (log.f64 a) a))) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (*.f64 a a)))))
(* a b)
(*.f64 a b)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)) (neg.f64 a))
(- y (log (- (+ a (+ x z)) 1/2)))
(-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 a x)))))
(* 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 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #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 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #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 y b) (/.f64 z b)) (-.f64 (/.f64 x b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 z x)))
(- (+ y z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
x
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(fma.f64 x (+.f64 (/.f64 y x) (-.f64 (/.f64 z x) (*.f64 z (/.f64 (log.f64 t) x)))) x)
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(fma.f64 x (+.f64 (/.f64 y x) (-.f64 (/.f64 z x) (*.f64 z (/.f64 (log.f64 t) x)))) x)
(* x (- (+ 1 (+ (/ y x) (/ z x))) (/ (* z (log t)) x)))
(fma.f64 x (+.f64 (/.f64 y x) (-.f64 (/.f64 z x) (*.f64 z (/.f64 (log.f64 t) x)))) x)
x
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(- (+ x z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
y
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(fma.f64 y (+.f64 (/.f64 z y) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) y) (/.f64 x y))) y)
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(fma.f64 y (+.f64 (/.f64 z y) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) y) (/.f64 x y))) y)
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(fma.f64 y (+.f64 (/.f64 z y) (fma.f64 (neg.f64 z) (/.f64 (log.f64 t) y) (/.f64 x y))) y)
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(+ x y)
(+.f64 y x)
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(fma.f64 z (+.f64 (/.f64 y z) (-.f64 (/.f64 x z) (log.f64 t))) z)
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(fma.f64 z (+.f64 (/.f64 y z) (-.f64 (/.f64 x z) (log.f64 t))) z)
(* z (- (+ 1 (+ (/ x z) (/ y z))) (log t)))
(fma.f64 z (+.f64 (/.f64 y z) (-.f64 (/.f64 x z) (log.f64 t))) z)
(* z (+ 1 (* -1 (log t))))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 #s(literal -1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 #s(literal -1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 #s(literal -1 binary64) (log.f64 t)) (/.f64 (+.f64 y x) z)) (neg.f64 z))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y x))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) (+.f64 y x))
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- (+ 1 (/ y z)) (log t)))
(+.f64 z (*.f64 z (-.f64 (/.f64 y z) (log.f64 t))))
(* z (- (+ 1 (/ y z)) (log t)))
(+.f64 z (*.f64 z (-.f64 (/.f64 y z) (log.f64 t))))
(* z (- (+ 1 (/ y z)) (log t)))
(+.f64 z (*.f64 z (-.f64 (/.f64 y z) (log.f64 t))))
(/ 1 z)
(/.f64 #s(literal 1 binary64) z)
(/ 1 z)
(/.f64 #s(literal 1 binary64) z)
(/ 1 z)
(/.f64 #s(literal 1 binary64) z)
(/ 1 z)
(/.f64 #s(literal 1 binary64) z)
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (* -1 (log (/ 1 t)))))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (* -1 (log (/ 1 t)))))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (* -1 (log (/ 1 t)))))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (* -1 (log (/ 1 t)))))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 z (neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) z)
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 z (neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) z)
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 z (neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) z)
(* z (- 1 (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 z (neg.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t)))) z)
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(* z (- 1 (log t)))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))
(/ 1 (* z (- 1 (log t))))
(/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) z))
(- 1 (log t))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(- (+ 1 (/ 1 y)) (log t))
(+.f64 (/.f64 #s(literal 1 binary64) y) (-.f64 #s(literal 1 binary64) (log.f64 t)))
(- (+ 1 (/ 1 y)) (log t))
(+.f64 (/.f64 #s(literal 1 binary64) y) (-.f64 #s(literal 1 binary64) (log.f64 t)))
(- (+ 1 (/ 1 y)) (log t))
(+.f64 (/.f64 #s(literal 1 binary64) y) (-.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 #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))))
-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 b)
(*.f64 a b)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 b a) (neg.f64 b)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 b a) (neg.f64 b)) (neg.f64 a))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(*.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 b a) (neg.f64 b)) (neg.f64 a))
(- 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 1/2)
(+.f64 a #s(literal -1/2 binary64))
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 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)))

rewrite824.0ms (5.3%)

Memory

23.7MiB live, 495.5MiB allocated

Rules

4 178×	`lower-/.f32`
4 174×	`lower-/.f64`
2 948×	`lower-*.f32`
2 946×	`lower-*.f64`
2 644×	`lower-fma.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	41	231
0	64	225
1	345	225
2	3006	225
0	8156	225

Stop Event

1×	iter limit
1×	node limit
1×	iter limit

Counts

20 → 697

Calls

Call 1

Inputs
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
(fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))
(/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z)))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(+.f64 a #s(literal -1/2 binary64))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
(-.f64 y (log1p.f64 (+.f64 z x)))
(log1p.f64 (+.f64 z x))
(+.f64 z x)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
(-.f64 #s(literal 1 binary64) (log.f64 t))
#s(approx (* (- a 1/2) b) (*.f64 b a))
(log.f64 t)

Outputs
(+.f64 z (-.f64 (+.f64 x y) (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 x (-.f64 (+.f64 z y) (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 (+.f64 z y) (-.f64 x (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)))
(+.f64 (+.f64 x (+.f64 z y)) (neg.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(+.f64 (+.f64 x y) (+.f64 (-.f64 z (.f64 (log.f64 t) z)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(+.f64 (+.f64 x y) (-.f64 z (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))))
(+.f64 (neg.f64 (.f64 (log.f64 t) z)) (+.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(+.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) (+.f64 (+.f64 z y) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))
(+.f64 (.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z))))) (.f64 #s(literal 1 binary64) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(+.f64 (.f64 #s(literal 1 binary64) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z))))))
(+.f64 (.f64 #s(literal 1 binary64) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z))) (.f64 #s(literal 1 binary64) (+.f64 x (+.f64 z y))))
(+.f64 (.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 1 binary64)) (.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(literal 1 binary64)))
(+.f64 (.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(literal 1 binary64)) (.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 1 binary64)))
(+.f64 (.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) #s(literal 1 binary64)) (.f64 (+.f64 x (+.f64 z y)) #s(literal 1 binary64)))
(+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 z y))) (neg.f64 (*.f64 (log.f64 t) z)))
(+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))
(+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) x)) (+.f64 z y))
(+.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) z) (+.f64 x y))
(+.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) x) (+.f64 z y))
(+.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (+.f64 z y)) x)
(+.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (+.f64 x y)) z)
(exp.f64 (log.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))))
(exp.f64 (.f64 (log.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 1 binary64)))
(-.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(-.f64 #s(literal 0 binary64) (/.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal -1 binary64)))
(-.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z))) (/.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z))))
(-.f64 (/.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(-.f64 (/.f64 (+.f64 x (+.f64 z y)) #s(literal 1 binary64)) (/.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 1 binary64)))
(-.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z))
(-.f64 (/.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z))) #s(literal 1 binary64)) (/.f64 (/.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z))) #s(literal 1 binary64)))
(-.f64 (/.f64 (/.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 1 binary64)) (/.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 1 binary64)))
(-.f64 (/.f64 (/.f64 (+.f64 x (+.f64 z y)) #s(literal 1 binary64)) #s(literal 1 binary64)) (/.f64 (/.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(-.f64 (/.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 z y))) #s(literal 1 binary64)) (/.f64 (*.f64 (log.f64 t) z) #s(literal 1 binary64)))
(-.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 x (+.f64 z y))) (.f64 (log.f64 t) z)))) (/.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)))))
(-.f64 (/.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(-.f64 (/.f64 (.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (+.f64 (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (/.f64 (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (+.f64 (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) 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 (log.f64 t) z)) #s(literal 2 binary64)) (-.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))) (/.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (-.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))))
(-.f64 (/.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (+.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (+.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(fma.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (.f64 #s(literal 1 binary64) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 #s(literal 1 binary64) (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z))))))
(fma.f64 #s(literal 1 binary64) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (*.f64 #s(literal 1 binary64) (+.f64 x (+.f64 z y))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))))
(fma.f64 (log.f64 t) (neg.f64 z) (+.f64 (+.f64 x (+.f64 z y)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 z (neg.f64 (log.f64 t)) (+.f64 (+.f64 x (+.f64 z y)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (neg.f64 z) (log.f64 t) (+.f64 (+.f64 x (+.f64 z y)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 1 binary64) (.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(literal 1 binary64)))
(fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(literal 1 binary64) (.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 1 binary64)))
(fma.f64 #s(literal -1 binary64) (.f64 (log.f64 t) z) (+.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (fma.f64 z (.f64 z z) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z y) (.f64 y y))) (-.f64 x (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (.f64 x x))) (+.f64 (-.f64 z (.f64 (log.f64 t) z)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (.f64 x x))) (-.f64 z (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 z y) (.f64 (+.f64 z y) (+.f64 z y)))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 z y) (-.f64 (+.f64 z y) x) (.f64 x x))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 z y) (.f64 (+.f64 z y) (+.f64 z y)))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 z y) (-.f64 (+.f64 z y) x) (.f64 x x))) (neg.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (.f64 (log.f64 t) z))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (.f64 (.f64 (log.f64 t) z) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y)))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (neg.f64 (log.f64 t)) z (+.f64 (+.f64 x (+.f64 z y)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (-.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (/.f64 #s(literal 1 binary64) (-.f64 (neg.f64 (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (.f64 (+.f64 z y) (-.f64 y z)) (/.f64 #s(literal 1 binary64) (-.f64 y z)) (-.f64 x (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (+.f64 (-.f64 z (.f64 (log.f64 t) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (-.f64 z (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x y) z)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x y) z)) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (log.f64 t) z)))
(fma.f64 (.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x y) z)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x y) z)) (neg.f64 (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (.f64 (+.f64 x (+.f64 z y)) (-.f64 x (+.f64 z y))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 z y))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (log.f64 t) z)))
(fma.f64 (.f64 (+.f64 x (+.f64 z y)) (-.f64 x (+.f64 z y))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 z y))) (neg.f64 (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) #s(literal 1 binary64) (*.f64 (+.f64 x (+.f64 z y)) #s(literal 1 binary64)))
(fma.f64 (.f64 (log.f64 t) #s(literal -1 binary64)) z (+.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(neg.f64 (neg.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (neg.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal -1 binary64))
(/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 2 binary64))))
(/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) (.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) (.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(/.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)))
(/.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) (.f64 #s(literal 1 binary64) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z))))
(/.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (neg.f64 (.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (neg.f64 (.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) (neg.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z))))
(/.f64 (neg.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) (neg.f64 (.f64 #s(literal 1 binary64) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (neg.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (neg.f64 (.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) 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 (log.f64 t) z)) #s(literal 3 binary64)) (.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))))) (+.f64 (pow.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) #s(literal 2 binary64)) (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y))))))
(/.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64))) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (+.f64 (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) 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 (log.f64 t) z)) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (-.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y))))
(/.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64))) (+.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))))
(/.f64 (.f64 #s(literal 1 binary64) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z)))
(/.f64 (.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (neg.f64 (neg.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) #s(literal 3 binary64)) (.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))))) (neg.f64 (+.f64 (pow.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) #s(literal 2 binary64)) (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (+.f64 (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))))) (neg.f64 (-.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)))) (neg.f64 (+.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))))) (neg.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))))) (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))))) (neg.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (neg.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (.f64 (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z)))) (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))))) #s(literal -1/2 binary64))
(.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))))
(.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) #s(literal 1 binary64))
(.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) (/.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z))))
(.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) (/.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(.f64 #s(literal -1 binary64) (neg.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z)))))
(.f64 #s(literal -1 binary64) (pow.f64 (neg.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 1 binary64)))
(.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z))))
(.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) #s(literal 1/2 binary64)) (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal 1/2 binary64)))
(.f64 (pow.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) #s(literal 1 binary64)))
(.f64 (pow.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) #s(literal 1 binary64)))
(.f64 (pow.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z))) #s(literal 1 binary64)))
(.f64 (pow.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 1 binary64)))
(.f64 (pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(.f64 (pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z))))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(.f64 (/.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 1 binary64)) (/.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(.f64 (/.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 1 binary64)) (/.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(.f64 (/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (/.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(.f64 (/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (/.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(+.f64 z (+.f64 (+.f64 x y) (neg.f64 (*.f64 (log.f64 t) z))))
(+.f64 z (-.f64 (+.f64 x y) (*.f64 (log.f64 t) z)))
(+.f64 x (+.f64 (+.f64 z y) (neg.f64 (*.f64 (log.f64 t) z))))
(+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z))))
(+.f64 x (-.f64 (+.f64 z y) (*.f64 (log.f64 t) z)))
(+.f64 y (+.f64 x (-.f64 z (*.f64 (log.f64 t) z))))
(+.f64 (+.f64 z y) (fma.f64 (log.f64 t) (neg.f64 z) x))
(+.f64 (+.f64 z y) (-.f64 x (*.f64 (log.f64 t) z)))
(+.f64 (+.f64 x (+.f64 z y)) (neg.f64 (*.f64 (log.f64 t) z)))
(+.f64 (+.f64 x y) (-.f64 z (*.f64 (log.f64 t) z)))
(+.f64 (neg.f64 (*.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))
(+.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) (+.f64 z y))
(+.f64 (-.f64 z (*.f64 (log.f64 t) z)) (+.f64 x y))
(+.f64 (fma.f64 (log.f64 t) (neg.f64 z) z) (+.f64 x y))
(+.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 z y)) x)
(+.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x y)) z)
(+.f64 (+.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) z) y)
(+.f64 (+.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) y) z)
(-.f64 (+.f64 x (+.f64 z y)) (*.f64 (log.f64 t) z))
(-.f64 (/.f64 (.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (.f64 (.f64 (log.f64 t) z) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y)))))) (/.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (.f64 (*.f64 (log.f64 t) z) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y)))))))
(-.f64 (/.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (-.f64 (neg.f64 (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))) (/.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (-.f64 (neg.f64 (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))))
(-.f64 (/.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y)))) (/.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y)))))
(-.f64 (/.f64 (.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (fma.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (.f64 (log.f64 t) z))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)))) (/.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (.f64 (log.f64 t) z))) (pow.f64 (*.f64 (log.f64 t) z) #s(literal 2 binary64)))))
(-.f64 (/.f64 (.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (-.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (.f64 (log.f64 t) (.f64 (neg.f64 z) (+.f64 x (+.f64 z y))))))) (/.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (-.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (.f64 (log.f64 t) (*.f64 (neg.f64 z) (+.f64 x (+.f64 z y))))))))
(-.f64 (/.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (.f64 (log.f64 t) z)))) (/.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (.f64 (log.f64 t) z)))))
(-.f64 (/.f64 (.f64 (+.f64 x y) (+.f64 x y)) (-.f64 (+.f64 x y) (-.f64 z (.f64 (log.f64 t) z)))) (/.f64 (pow.f64 (-.f64 z (.f64 (log.f64 t) z)) #s(literal 2 binary64)) (-.f64 (+.f64 x y) (-.f64 z (.f64 (log.f64 t) z)))))
(-.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) #s(literal 2 binary64)) (-.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) (+.f64 z y))) (/.f64 (*.f64 (+.f64 z y) (+.f64 z y)) (-.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) (+.f64 z y))))
(fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 z y)))
(fma.f64 z (neg.f64 (log.f64 t)) (+.f64 x (+.f64 z y)))
(fma.f64 (neg.f64 z) (log.f64 t) (+.f64 x (+.f64 z y)))
(fma.f64 #s(literal -1 binary64) (*.f64 (log.f64 t) z) (+.f64 x (+.f64 z y)))
(fma.f64 (fma.f64 z (.f64 z z) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z y) (.f64 y y))) (fma.f64 (log.f64 t) (neg.f64 z) x))
(fma.f64 (fma.f64 z (.f64 z z) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z y) (.f64 y y))) (-.f64 x (*.f64 (log.f64 t) z)))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (.f64 x x))) (-.f64 z (*.f64 (log.f64 t) z)))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (*.f64 (log.f64 t) z)))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 z y) (.f64 (+.f64 z y) (+.f64 z y)))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 z y) (-.f64 (+.f64 z y) x) (.f64 x x))) (neg.f64 (*.f64 (log.f64 t) z)))
(fma.f64 (neg.f64 (log.f64 t)) z (+.f64 x (+.f64 z y)))
(fma.f64 (*.f64 (+.f64 z y) (-.f64 y z)) (/.f64 #s(literal 1 binary64) (-.f64 y z)) (fma.f64 (log.f64 t) (neg.f64 z) x))
(fma.f64 (.f64 (+.f64 z y) (-.f64 y z)) (/.f64 #s(literal 1 binary64) (-.f64 y z)) (-.f64 x (.f64 (log.f64 t) z)))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (-.f64 z (.f64 (log.f64 t) z)))
(fma.f64 (.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x y) z)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x y) z)) (neg.f64 (.f64 (log.f64 t) z)))
(fma.f64 (.f64 (+.f64 x (+.f64 z y)) (-.f64 x (+.f64 z y))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 z y))) (neg.f64 (.f64 (log.f64 t) z)))
(fma.f64 (*.f64 (log.f64 t) #s(literal -1 binary64)) z (+.f64 x (+.f64 z y)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (.f64 (log.f64 t) z))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64))) (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (.f64 (.f64 (log.f64 t) z) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y))))) (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (neg.f64 (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y))) (-.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y))) (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (.f64 (log.f64 t) z))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64))) (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (.f64 (.f64 (log.f64 t) z) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y))))) (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (neg.f64 (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y))) (-.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y))) (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64))))))
(/.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64))) (fma.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (.f64 (log.f64 t) z))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64))))
(/.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64))) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (.f64 (.f64 (log.f64 t) z) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y))))))
(/.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64))) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (-.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (.f64 (log.f64 t) (*.f64 (neg.f64 z) (+.f64 x (+.f64 z y)))))))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (-.f64 (neg.f64 (*.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y))))
(/.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64))) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y))))
(/.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64))) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (*.f64 (log.f64 t) z))))
(/.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (.f64 (log.f64 t) z))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (.f64 (.f64 (log.f64 t) z) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y)))))))
(/.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (-.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (.f64 (log.f64 t) (*.f64 (neg.f64 z) (+.f64 x (+.f64 z y))))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))))) (neg.f64 (-.f64 (neg.f64 (*.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)))) (neg.f64 (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y)))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (*.f64 (log.f64 t) z)))))
(/.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (.f64 (log.f64 t) z)) #s(literal 3 binary64))) (fma.f64 (+.f64 x y) (+.f64 x y) (-.f64 (pow.f64 (-.f64 z (.f64 (log.f64 t) z)) #s(literal 2 binary64)) (.f64 (+.f64 x y) (-.f64 z (*.f64 (log.f64 t) z))))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) #s(literal 3 binary64)) (.f64 (+.f64 z y) (.f64 (+.f64 z y) (+.f64 z y)))) (+.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) #s(literal 2 binary64)) (-.f64 (.f64 (+.f64 z y) (+.f64 z y)) (.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) (+.f64 z y)))))
(/.f64 (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (.f64 (log.f64 t) z)) #s(literal 2 binary64))) (-.f64 (+.f64 x y) (-.f64 z (*.f64 (log.f64 t) z))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) #s(literal 2 binary64)) (*.f64 (+.f64 z y) (+.f64 z y))) (-.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) (+.f64 z y)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (.f64 (log.f64 t) z))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (.f64 (.f64 (log.f64 t) z) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y))))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))))) (neg.f64 (neg.f64 (-.f64 (neg.f64 (*.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y))))))
(/.f64 (neg.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (.f64 (log.f64 t) z)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 x y) (+.f64 x y) (-.f64 (pow.f64 (-.f64 z (.f64 (log.f64 t) z)) #s(literal 2 binary64)) (.f64 (+.f64 x y) (-.f64 z (*.f64 (log.f64 t) z)))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) #s(literal 3 binary64)) (.f64 (+.f64 z y) (.f64 (+.f64 z y) (+.f64 z y))))) (neg.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) #s(literal 2 binary64)) (-.f64 (.f64 (+.f64 z y) (+.f64 z y)) (.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) (+.f64 z y))))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 x y) (+.f64 x y)) (pow.f64 (-.f64 z (.f64 (log.f64 t) z)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 x y) (-.f64 z (*.f64 (log.f64 t) z)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) #s(literal 2 binary64)) (*.f64 (+.f64 z y) (+.f64 z y)))) (neg.f64 (-.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) (+.f64 z y))))
(pow.f64 (/.f64 (fma.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (.f64 (log.f64 t) z))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64))) (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (.f64 (.f64 (log.f64 t) z) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y))))) (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (neg.f64 (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y))) (-.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (*.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y))) (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)))) #s(literal -1 binary64))
(.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (.f64 (log.f64 t) z))) (pow.f64 (*.f64 (log.f64 t) z) #s(literal 2 binary64)))))
(.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (.f64 (*.f64 (log.f64 t) z) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y)))))))
(.f64 (-.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (/.f64 #s(literal 1 binary64) (-.f64 (neg.f64 (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))))
(.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (*.f64 (log.f64 t) z) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y)))))
(exp.f64 (neg.f64 (log.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))))))
(exp.f64 (.f64 (neg.f64 (log.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))))) #s(literal 1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal -1 binary64)))
(neg.f64 (/.f64 #s(literal -1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))))
(/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))))
(/.f64 (/.f64 #s(literal -1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal -1 binary64))
(pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 1 binary64))
(pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal -1/2 binary64))
(.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z)))))
(.f64 (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 1 binary64))
(.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z)))))
(.f64 #s(literal -1 binary64) (pow.f64 (/.f64 #s(literal -1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 1 binary64)))
(.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) #s(literal -1/2 binary64)) (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal -1/2 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))))
(.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) #s(literal -1 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) #s(literal -1 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z)))
(.f64 (/.f64 #s(literal 1 binary64) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z))) #s(literal -1 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(.f64 (/.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal -1 binary64)))
(.f64 (pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) #s(literal 1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal 1/2 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) #s(literal 1 binary64)) (pow.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 1 binary64)))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) #s(literal 1 binary64)) (pow.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) #s(literal 1 binary64)))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) #s(literal 1 binary64)) (pow.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z)) #s(literal 1 binary64)))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) #s(literal 1 binary64)) (pow.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) #s(literal 1 binary64)))
(+.f64 z (-.f64 (+.f64 x y) (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 x (-.f64 (+.f64 z y) (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 (+.f64 z y) (-.f64 x (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)))
(+.f64 (+.f64 x (+.f64 z y)) (neg.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(+.f64 (+.f64 x y) (+.f64 (-.f64 z (.f64 (log.f64 t) z)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(+.f64 (+.f64 x y) (-.f64 z (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(+.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))))
(+.f64 (neg.f64 (.f64 (log.f64 t) z)) (+.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(+.f64 (fma.f64 (log.f64 t) (neg.f64 z) x) (+.f64 (+.f64 z y) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))
(+.f64 (.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z))))) (.f64 #s(literal 1 binary64) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(+.f64 (.f64 #s(literal 1 binary64) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z))))))
(+.f64 (.f64 #s(literal 1 binary64) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z))) (.f64 #s(literal 1 binary64) (+.f64 x (+.f64 z y))))
(+.f64 (.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 1 binary64)) (.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(literal 1 binary64)))
(+.f64 (.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(literal 1 binary64)) (.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 1 binary64)))
(+.f64 (.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) #s(literal 1 binary64)) (.f64 (+.f64 x (+.f64 z y)) #s(literal 1 binary64)))
(+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 z y))) (neg.f64 (*.f64 (log.f64 t) z)))
(+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))
(+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) x)) (+.f64 z y))
(+.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) z) (+.f64 x y))
(+.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) x) (+.f64 z y))
(+.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (+.f64 z y)) x)
(+.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (+.f64 x y)) z)
(exp.f64 (log.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))))
(exp.f64 (.f64 (log.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 1 binary64)))
(-.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(-.f64 #s(literal 0 binary64) (/.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal -1 binary64)))
(-.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z))) (/.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z))))
(-.f64 (/.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(-.f64 (/.f64 (+.f64 x (+.f64 z y)) #s(literal 1 binary64)) (/.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 1 binary64)))
(-.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z))
(-.f64 (/.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z))) #s(literal 1 binary64)) (/.f64 (/.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z))) #s(literal 1 binary64)))
(-.f64 (/.f64 (/.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 1 binary64)) (/.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 1 binary64)))
(-.f64 (/.f64 (/.f64 (+.f64 x (+.f64 z y)) #s(literal 1 binary64)) #s(literal 1 binary64)) (/.f64 (/.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(-.f64 (/.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 z y))) #s(literal 1 binary64)) (/.f64 (*.f64 (log.f64 t) z) #s(literal 1 binary64)))
(-.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.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 x (+.f64 z y))) (.f64 (log.f64 t) z)))) (/.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)))))
(-.f64 (/.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(-.f64 (/.f64 (.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (+.f64 (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (/.f64 (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64)) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (+.f64 (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) 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 (log.f64 t) z)) #s(literal 2 binary64)) (-.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))) (/.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (-.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))))
(-.f64 (/.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (+.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (+.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(fma.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (.f64 #s(literal 1 binary64) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 #s(literal 1 binary64) (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z))))))
(fma.f64 #s(literal 1 binary64) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (*.f64 #s(literal 1 binary64) (+.f64 x (+.f64 z y))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))))
(fma.f64 (log.f64 t) (neg.f64 z) (+.f64 (+.f64 x (+.f64 z y)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 z (neg.f64 (log.f64 t)) (+.f64 (+.f64 x (+.f64 z y)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (neg.f64 z) (log.f64 t) (+.f64 (+.f64 x (+.f64 z y)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 1 binary64) (.f64 (*.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(literal 1 binary64)))
(fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(literal 1 binary64) (.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 1 binary64)))
(fma.f64 #s(literal -1 binary64) (.f64 (log.f64 t) z) (+.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (fma.f64 z (.f64 z z) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z y) (.f64 y y))) (-.f64 x (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (.f64 x x))) (+.f64 (-.f64 z (.f64 (log.f64 t) z)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (.f64 x x))) (-.f64 z (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)))
(fma.f64 (fma.f64 (+.f64 x y) (.f64 (+.f64 x y) (+.f64 x y)) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 z y) (.f64 (+.f64 z y) (+.f64 z y)))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 z y) (-.f64 (+.f64 z y) x) (.f64 x x))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)))
(fma.f64 (fma.f64 x (.f64 x x) (.f64 (+.f64 z y) (.f64 (+.f64 z y) (+.f64 z y)))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 z y) (-.f64 (+.f64 z y) x) (.f64 x x))) (neg.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x (+.f64 z y)) (neg.f64 (.f64 (log.f64 t) z))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (fma.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (.f64 (.f64 (log.f64 t) z) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y)))))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (neg.f64 (log.f64 t)) z (+.f64 (+.f64 x (+.f64 z y)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (-.f64 (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (/.f64 #s(literal 1 binary64) (-.f64 (neg.f64 (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (.f64 (+.f64 z y) (-.f64 y z)) (/.f64 #s(literal 1 binary64) (-.f64 y z)) (-.f64 x (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (+.f64 (-.f64 z (.f64 (log.f64 t) z)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(fma.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) (-.f64 z (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x y) z)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x y) z)) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (log.f64 t) z)))
(fma.f64 (.f64 (+.f64 x (+.f64 z y)) (-.f64 (+.f64 x y) z)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x y) z)) (neg.f64 (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (.f64 (+.f64 x (+.f64 z y)) (-.f64 x (+.f64 z y))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 z y))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (log.f64 t) z)))
(fma.f64 (.f64 (+.f64 x (+.f64 z y)) (-.f64 x (+.f64 z y))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 z y))) (neg.f64 (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (.f64 (log.f64 t) z) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) z (+.f64 x (+.f64 z y)))) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(fma.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) #s(literal 1 binary64) (*.f64 (+.f64 x (+.f64 z y)) #s(literal 1 binary64)))
(fma.f64 (.f64 (log.f64 t) #s(literal -1 binary64)) z (+.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(neg.f64 (neg.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (neg.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal -1 binary64))
(/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 2 binary64))))
(/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) (.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) (.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(/.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)))
(/.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) (.f64 #s(literal 1 binary64) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z))))
(/.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (neg.f64 (.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (neg.f64 (.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) (neg.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z))))
(/.f64 (neg.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) (neg.f64 (.f64 #s(literal 1 binary64) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (neg.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (neg.f64 (.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) 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 (log.f64 t) z)) #s(literal 3 binary64)) (.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))))) (+.f64 (pow.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) #s(literal 2 binary64)) (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y))))))
(/.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64))) (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (+.f64 (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) 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 (log.f64 t) z)) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (-.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y))))
(/.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64))) (+.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))))
(/.f64 (.f64 #s(literal 1 binary64) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z)))
(/.f64 (.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (neg.f64 (neg.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) #s(literal 3 binary64)) (.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))))) (neg.f64 (+.f64 (pow.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) #s(literal 2 binary64)) (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)))) (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y)) (+.f64 (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 (log.f64 t) z)) #s(literal 2 binary64)) (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))))) (neg.f64 (-.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (*.f64 (log.f64 t) z)) (+.f64 x (+.f64 z y)))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 x (+.f64 z y)) (+.f64 x (+.f64 z y))) (pow.f64 (-.f64 (.f64 (log.f64 t) z) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) #s(literal 2 binary64)))) (neg.f64 (+.f64 (+.f64 x (+.f64 z y)) (-.f64 (.f64 (log.f64 t) z) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))))) (neg.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))))) (neg.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))))) (neg.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))) (neg.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (.f64 (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z)))) (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))))) #s(literal -1/2 binary64))
(.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))))
(.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) #s(literal 1 binary64))
(.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) (/.f64 (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z))))
(.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) (/.f64 (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(.f64 #s(literal -1 binary64) (neg.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z)))))
(.f64 #s(literal -1 binary64) (pow.f64 (neg.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 1 binary64)))
(.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z))))
(.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) #s(literal 1/2 binary64)) (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal 1/2 binary64)))
(.f64 (pow.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) #s(literal 1 binary64)))
(.f64 (pow.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) #s(literal 1 binary64)))
(.f64 (pow.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z))) #s(literal 1 binary64)))
(.f64 (pow.f64 (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 1 binary64)))
(.f64 (pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(.f64 (pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (*.f64 (log.f64 t) z))) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 3 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (*.f64 (log.f64 t) z))))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(.f64 (/.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 1 binary64)) (/.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(.f64 (/.f64 (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) #s(literal 1 binary64)) (/.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (*.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
(.f64 (/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (/.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) (fma.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) (-.f64 (+.f64 x (+.f64 z y)) (fma.f64 (log.f64 t) z (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(.f64 (/.f64 (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64))) #s(literal 1 binary64)) (/.f64 (+.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (+.f64 x y)) (-.f64 z (.f64 (log.f64 t) z))) (fma.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) (+.f64 x (+.f64 z y))) (.f64 (log.f64 t) z)) (pow.f64 (+.f64 x (+.f64 y (-.f64 z (.f64 (log.f64 t) z)))) #s(literal 2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 (+.f64 a #s(literal -1/2 binary64)) y))
(+.f64 a (+.f64 #s(literal -1/2 binary64) y))
(+.f64 #s(literal -1/2 binary64) (+.f64 a y))
(+.f64 (+.f64 a #s(literal -1/2 binary64)) y)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(+.f64 (+.f64 a y) #s(literal -1/2 binary64))
(+.f64 (+.f64 y #s(literal -1/2 binary64)) a)
(-.f64 a (-.f64 #s(literal 1/2 binary64) y))
(-.f64 (+.f64 a y) #s(literal 1/2 binary64))
(-.f64 (/.f64 (.f64 y y) (-.f64 y (+.f64 a #s(literal -1/2 binary64)))) (/.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (-.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(-.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)) y)) (/.f64 (.f64 y y) (-.f64 (+.f64 a #s(literal -1/2 binary64)) y)))
(-.f64 (/.f64 (*.f64 (+.f64 a y) (+.f64 a y)) (-.f64 (+.f64 a y) #s(literal -1/2 binary64))) (/.f64 #s(literal 1/4 binary64) (-.f64 (+.f64 a y) #s(literal -1/2 binary64))))
(fma.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 a a #s(literal 1/4 binary64)) (.f64 a #s(literal -1/2 binary64)))) y)
(fma.f64 (fma.f64 a (*.f64 a a) #s(literal -1/8 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))) y)
(fma.f64 (fma.f64 a a #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))) y)
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (-.f64 (+.f64 a #s(literal -1/2 binary64)) y) (.f64 y y)) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (.f64 y (.f64 y y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 y (+.f64 a #s(literal -1/2 binary64))) (*.f64 (+.f64 (+.f64 a #s(literal -1/2 binary64)) y) (-.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (-.f64 (+.f64 a #s(literal -1/2 binary64)) y) (.f64 y y)) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (.f64 y (.f64 y y))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 y (+.f64 a #s(literal -1/2 binary64))) (*.f64 (+.f64 (+.f64 a #s(literal -1/2 binary64)) y) (-.f64 y (+.f64 a #s(literal -1/2 binary64)))))))
(/.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (.f64 y (.f64 y y))) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (-.f64 (+.f64 a #s(literal -1/2 binary64)) y) (.f64 y y)))
(/.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (.f64 y (.f64 y y))) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)) (-.f64 (.f64 y y) (*.f64 (+.f64 a #s(literal -1/2 binary64)) y))))
(/.f64 (*.f64 (+.f64 (+.f64 a #s(literal -1/2 binary64)) y) (-.f64 y (+.f64 a #s(literal -1/2 binary64)))) (-.f64 y (+.f64 a #s(literal -1/2 binary64))))
(/.f64 (neg.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (-.f64 (+.f64 a #s(literal -1/2 binary64)) y) (.f64 y y))))
(/.f64 (neg.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64)) (-.f64 (.f64 y y) (*.f64 (+.f64 a #s(literal -1/2 binary64)) y)))))
(/.f64 (neg.f64 (*.f64 (+.f64 (+.f64 a #s(literal -1/2 binary64)) y) (-.f64 y (+.f64 a #s(literal -1/2 binary64))))) (neg.f64 (-.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(/.f64 (fma.f64 (+.f64 a y) (.f64 (+.f64 a y) (+.f64 a y)) #s(literal -1/8 binary64)) (fma.f64 (+.f64 a y) (+.f64 a y) (-.f64 #s(literal 1/4 binary64) (.f64 (+.f64 a y) #s(literal -1/2 binary64)))))
(/.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (.f64 y y)) (-.f64 (+.f64 a #s(literal -1/2 binary64)) y))
(/.f64 (-.f64 (*.f64 (+.f64 a y) (+.f64 a y)) #s(literal 1/4 binary64)) (-.f64 (+.f64 a y) #s(literal -1/2 binary64)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (.f64 y (.f64 y y))))) (neg.f64 (neg.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (-.f64 (+.f64 a #s(literal -1/2 binary64)) y) (.f64 y y)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 (+.f64 a #s(literal -1/2 binary64)) y) (-.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (neg.f64 (neg.f64 (-.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (fma.f64 (+.f64 a y) (.f64 (+.f64 a y) (+.f64 a y)) #s(literal -1/8 binary64))) (neg.f64 (fma.f64 (+.f64 a y) (+.f64 a y) (-.f64 #s(literal 1/4 binary64) (.f64 (+.f64 a y) #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (.f64 y y))) (neg.f64 (-.f64 (+.f64 a #s(literal -1/2 binary64)) y)))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 a y) (+.f64 a y)) #s(literal 1/4 binary64))) (neg.f64 (-.f64 (+.f64 a y) #s(literal -1/2 binary64))))
(pow.f64 (/.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (-.f64 (+.f64 a #s(literal -1/2 binary64)) y) (.f64 y y)) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (.f64 y (.f64 y y)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 y (+.f64 a #s(literal -1/2 binary64))) (*.f64 (+.f64 (+.f64 a #s(literal -1/2 binary64)) y) (-.f64 y (+.f64 a #s(literal -1/2 binary64))))) #s(literal -1 binary64))
(.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) (+.f64 a #s(literal -1/2 binary64))) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (-.f64 (+.f64 a #s(literal -1/2 binary64)) y) (*.f64 y y))))
(.f64 (.f64 (+.f64 (+.f64 a #s(literal -1/2 binary64)) y) (-.f64 y (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(+.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)) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))) (/.f64 #s(literal 1/8 binary64) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 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 (/.f64 (.f64 a (.f64 a a)) (-.f64 (fma.f64 a a #s(literal 1/4 binary64)) (.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1/8 binary64) (-.f64 (fma.f64 a a #s(literal 1/4 binary64)) (.f64 a #s(literal -1/2 binary64)))))
(-.f64 (/.f64 (.f64 a (.f64 a a)) (+.f64 #s(literal 1/4 binary64) (-.f64 (.f64 a a) (.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/8 binary64) (+.f64 #s(literal 1/4 binary64) (-.f64 (.f64 a a) (.f64 a #s(literal -1/2 binary64))))))
(-.f64 (/.f64 #s(literal 1/4 binary64) (-.f64 #s(literal -1/2 binary64) a)) (/.f64 (*.f64 a a) (-.f64 #s(literal -1/2 binary64) a)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 a a #s(literal 1/4 binary64)) (.f64 a #s(literal -1/2 binary64))) (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.f64 a (*.f64 a a) #s(literal -1/8 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 a #s(literal 1/2 binary64)) (fma.f64 a a #s(literal -1/4 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (fma.f64 a a #s(literal 1/4 binary64)) (.f64 a #s(literal -1/2 binary64))) (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.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)) (fma.f64 a a #s(literal -1/4 binary64)))))
(/.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) (-.f64 (fma.f64 a a #s(literal 1/4 binary64)) (.f64 a #s(literal -1/2 binary64))))
(/.f64 (fma.f64 a (*.f64 a a) #s(literal -1/8 binary64)) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))))
(/.f64 (fma.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 (fma.f64 a a #s(literal -1/4 binary64)) (+.f64 a #s(literal 1/2 binary64)))
(/.f64 (neg.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) (neg.f64 (-.f64 (fma.f64 a a #s(literal 1/4 binary64)) (.f64 a #s(literal -1/2 binary64)))))
(/.f64 (neg.f64 (fma.f64 a (*.f64 a a) #s(literal -1/8 binary64))) (neg.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(/.f64 (neg.f64 (fma.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 (fma.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 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)))) (neg.f64 (neg.f64 (-.f64 (fma.f64 a a #s(literal 1/4 binary64)) (.f64 a #s(literal -1/2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 a (*.f64 a a) #s(literal -1/8 binary64)))) (neg.f64 (neg.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))))))
(/.f64 (neg.f64 (neg.f64 (fma.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 (fma.f64 a a #s(literal 1/4 binary64)) (.f64 a #s(literal -1/2 binary64))) (fma.f64 a (.f64 a a) #s(literal -1/8 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (fma.f64 a (*.f64 a a) #s(literal -1/8 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 a #s(literal 1/2 binary64)) (fma.f64 a a #s(literal -1/4 binary64))) #s(literal -1 binary64))
(.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 a a #s(literal 1/4 binary64)) (*.f64 a #s(literal -1/2 binary64)))))
(.f64 (fma.f64 a (.f64 a a) #s(literal -1/8 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 a a (fma.f64 a #s(literal 1/2 binary64) #s(literal 1/4 binary64)))))
(*.f64 (fma.f64 a a #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 a #s(literal 1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))
(+.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))
(-.f64 (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (/.f64 (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))
(-.f64 (/.f64 (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (/.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.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 b (*.f64 b b))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.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 b (*.f64 b b)))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))))
(/.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.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 b (.f64 b b)))) (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))
(/.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.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 b (.f64 b b)))) (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))))
(/.f64 (.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))
(/.f64 (neg.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.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 b (.f64 b b))))) (neg.f64 (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(/.f64 (neg.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.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 b (.f64 b b))))) (neg.f64 (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))))))
(/.f64 (neg.f64 (.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))) (neg.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))
(/.f64 (-.f64 (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.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 b (.f64 b b)))))) (neg.f64 (neg.f64 (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))) (neg.f64 (neg.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))))
(/.f64 (neg.f64 (-.f64 (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))) (neg.f64 (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (*.f64 (+.f64 a #s(literal -1/2 binary64)) b))))
(pow.f64 (/.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.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 b (*.f64 b b))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))) #s(literal -1 binary64))
(.f64 (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.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 b (.f64 b b)))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))))
(.f64 (.f64 (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 (+.f64 a #s(literal -1/2 binary64)) b) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
(+.f64 y x)
(-.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)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 y (-.f64 y x) (.f64 x x)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 x y) (*.f64 (+.f64 x y) (-.f64 x y))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 y (-.f64 y x) (.f64 x x)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 x y) (*.f64 (+.f64 x y) (-.f64 x y)))))
(/.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 y (-.f64 y x) (.f64 x x)))
(/.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 y y (-.f64 (.f64 x x) (*.f64 x y))))
(/.f64 (*.f64 (+.f64 x y) (-.f64 x y)) (-.f64 x y))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x))))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 y y (-.f64 (.f64 x x) (*.f64 x y)))))
(/.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y))) (neg.f64 (-.f64 x y)))
(/.f64 (-.f64 (.f64 y y) (.f64 x x)) (-.f64 y x))
(/.f64 (neg.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))))) (neg.f64 (neg.f64 (fma.f64 y (-.f64 y x) (.f64 x x)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x 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 (fma.f64 y (-.f64 y x) (.f64 x x)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 x y) (*.f64 (+.f64 x y) (-.f64 x y))) #s(literal -1 binary64))
(.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (*.f64 x x))))
(.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
(+.f64 y (neg.f64 (log1p.f64 (+.f64 z x))))
(+.f64 (neg.f64 (log1p.f64 (+.f64 z x))) y)
(-.f64 y (log1p.f64 (+.f64 z x)))
(-.f64 (/.f64 (.f64 y (.f64 y y)) (fma.f64 (log1p.f64 (+.f64 z x)) (+.f64 y (log1p.f64 (+.f64 z x))) (.f64 y y))) (/.f64 (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 3 binary64)) (fma.f64 (log1p.f64 (+.f64 z x)) (+.f64 y (log1p.f64 (+.f64 z x))) (.f64 y y))))
(-.f64 (/.f64 (*.f64 y y) (+.f64 y (log1p.f64 (+.f64 z x)))) (/.f64 (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 2 binary64)) (+.f64 y (log1p.f64 (+.f64 z x)))))
(-.f64 (/.f64 (*.f64 y y) (-.f64 y (neg.f64 (log1p.f64 (+.f64 z x))))) (/.f64 (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 2 binary64)) (-.f64 y (neg.f64 (log1p.f64 (+.f64 z x))))))
(fma.f64 #s(literal -1 binary64) (log1p.f64 (+.f64 z x)) y)
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log1p.f64 (+.f64 z x)) (+.f64 y (log1p.f64 (+.f64 z x))) (.f64 y y)) (-.f64 (.f64 y (*.f64 y y)) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 y (log1p.f64 (+.f64 z x))) (-.f64 (*.f64 y y) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (log1p.f64 (+.f64 z x)) (+.f64 y (log1p.f64 (+.f64 z x))) (.f64 y y)) (-.f64 (.f64 y (*.f64 y y)) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (+.f64 y (log1p.f64 (+.f64 z x))) (-.f64 (*.f64 y y) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 2 binary64))))))
(/.f64 (-.f64 (.f64 y (.f64 y y)) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 3 binary64))) (fma.f64 (log1p.f64 (+.f64 z x)) (+.f64 y (log1p.f64 (+.f64 z x))) (*.f64 y y)))
(/.f64 (-.f64 (.f64 y (.f64 y y)) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 2 binary64)) (*.f64 y (neg.f64 (log1p.f64 (+.f64 z x)))))))
(/.f64 (-.f64 (*.f64 y y) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 2 binary64))) (+.f64 y (log1p.f64 (+.f64 z x))))
(/.f64 (-.f64 (*.f64 y y) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 2 binary64))) (-.f64 y (neg.f64 (log1p.f64 (+.f64 z x)))))
(/.f64 (neg.f64 (-.f64 (.f64 y (.f64 y y)) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (log1p.f64 (+.f64 z x)) (+.f64 y (log1p.f64 (+.f64 z x))) (*.f64 y y))))
(/.f64 (neg.f64 (-.f64 (.f64 y (.f64 y y)) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 y y (-.f64 (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 2 binary64)) (*.f64 y (neg.f64 (log1p.f64 (+.f64 z x))))))))
(/.f64 (neg.f64 (-.f64 (*.f64 y y) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 2 binary64)))) (neg.f64 (+.f64 y (log1p.f64 (+.f64 z x)))))
(/.f64 (neg.f64 (-.f64 (*.f64 y y) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 2 binary64)))) (neg.f64 (-.f64 y (neg.f64 (log1p.f64 (+.f64 z x))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (.f64 y (.f64 y y)) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 (log1p.f64 (+.f64 z x)) (+.f64 y (log1p.f64 (+.f64 z x))) (*.f64 y y)))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (*.f64 y y) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 2 binary64))))) (neg.f64 (neg.f64 (+.f64 y (log1p.f64 (+.f64 z x))))))
(pow.f64 (/.f64 (fma.f64 (log1p.f64 (+.f64 z x)) (+.f64 y (log1p.f64 (+.f64 z x))) (.f64 y y)) (-.f64 (.f64 y (*.f64 y y)) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 y (log1p.f64 (+.f64 z x))) (-.f64 (*.f64 y y) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(.f64 (-.f64 (.f64 y (.f64 y y)) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log1p.f64 (+.f64 z x)) (+.f64 y (log1p.f64 (+.f64 z x))) (.f64 y y))))
(.f64 (-.f64 (.f64 y y) (pow.f64 (log1p.f64 (+.f64 z x)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 y (log1p.f64 (+.f64 z x)))))
(log.f64 (+.f64 #s(literal 1 binary64) (+.f64 z x)))
(+.f64 (log1p.f64 (.f64 (+.f64 z x) (.f64 (+.f64 z x) (+.f64 z x)))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 z x) (-.f64 (+.f64 z x) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(+.f64 (log1p.f64 (neg.f64 (*.f64 (+.f64 z x) (+.f64 z x)))) (log.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (+.f64 z x)))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (fma.f64 (+.f64 z x) (-.f64 (+.f64 z x) #s(literal 1 binary64)) #s(literal 1 binary64)) (fma.f64 (+.f64 z x) (*.f64 (+.f64 z x) (+.f64 z x)) #s(literal 1 binary64)))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (-.f64 #s(literal 1 binary64) (+.f64 z x)) (-.f64 #s(literal 1 binary64) (*.f64 (+.f64 z x) (+.f64 z x))))))
(-.f64 (log1p.f64 (.f64 (+.f64 z x) (.f64 (+.f64 z x) (+.f64 z x)))) (log1p.f64 (*.f64 (+.f64 z x) (-.f64 (+.f64 z x) #s(literal 1 binary64)))))
(-.f64 (log1p.f64 (.f64 (+.f64 z x) (.f64 (+.f64 z x) (+.f64 z x)))) (log.f64 (fma.f64 (+.f64 z x) (+.f64 z x) (-.f64 #s(literal 1 binary64) (+.f64 z x)))))
(-.f64 (log1p.f64 (neg.f64 (*.f64 (+.f64 z x) (+.f64 z x)))) (log1p.f64 (neg.f64 (+.f64 z x))))
(-.f64 (log.f64 (neg.f64 (fma.f64 (+.f64 z x) (*.f64 (+.f64 z x) (+.f64 z x)) #s(literal 1 binary64)))) (log.f64 (neg.f64 (fma.f64 (+.f64 z x) (-.f64 (+.f64 z x) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(-.f64 (log.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (*.f64 (+.f64 z x) (+.f64 z x))))) (log.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (+.f64 z x)))))
(-.f64 (log.f64 (fma.f64 (+.f64 #s(literal 1 binary64) z) (.f64 (+.f64 #s(literal 1 binary64) z) (+.f64 #s(literal 1 binary64) z)) (.f64 x (.f64 x x)))) (log.f64 (fma.f64 (+.f64 #s(literal 1 binary64) z) (+.f64 #s(literal 1 binary64) z) (-.f64 (.f64 x x) (*.f64 (+.f64 #s(literal 1 binary64) z) x)))))
(-.f64 (log.f64 (-.f64 (*.f64 (+.f64 z x) (+.f64 z x)) #s(literal 1 binary64))) (log.f64 (-.f64 (+.f64 z x) #s(literal 1 binary64))))
(-.f64 (log.f64 (-.f64 (.f64 (+.f64 #s(literal 1 binary64) z) (+.f64 #s(literal 1 binary64) z)) (.f64 x x))) (log.f64 (-.f64 (+.f64 #s(literal 1 binary64) z) x)))
(neg.f64 (log.f64 (/.f64 (fma.f64 (+.f64 z x) (-.f64 (+.f64 z x) #s(literal 1 binary64)) #s(literal 1 binary64)) (fma.f64 (+.f64 z x) (*.f64 (+.f64 z x) (+.f64 z x)) #s(literal 1 binary64)))))
(neg.f64 (log.f64 (/.f64 (-.f64 #s(literal 1 binary64) (+.f64 z x)) (-.f64 #s(literal 1 binary64) (*.f64 (+.f64 z x) (+.f64 z x))))))
(log1p.f64 (+.f64 z x))
(+.f64 z x)
(+.f64 x z)
(+.f64 (.f64 #s(literal 1 binary64) z) (.f64 #s(literal 1 binary64) x))
(+.f64 (.f64 z #s(literal 1 binary64)) (.f64 x #s(literal 1 binary64)))
(+.f64 (.f64 #s(literal 1 binary64) x) (.f64 #s(literal 1 binary64) z))
(+.f64 (.f64 x #s(literal 1 binary64)) (.f64 z #s(literal 1 binary64)))
(-.f64 (/.f64 (.f64 z z) (-.f64 z x)) (/.f64 (.f64 x x) (-.f64 z x)))
(-.f64 (/.f64 (.f64 x x) (-.f64 x z)) (/.f64 (.f64 z z) (-.f64 x z)))
(fma.f64 #s(literal 1 binary64) z (*.f64 #s(literal 1 binary64) x))
(fma.f64 #s(literal 1 binary64) x (*.f64 #s(literal 1 binary64) z))
(fma.f64 z #s(literal 1 binary64) (*.f64 x #s(literal 1 binary64)))
(fma.f64 x #s(literal 1 binary64) (*.f64 z #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x z) (.f64 z z)) (fma.f64 x (.f64 x x) (.f64 z (.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z x) (*.f64 (+.f64 z x) (-.f64 z x))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 x (-.f64 x z) (.f64 z z)) (fma.f64 x (.f64 x x) (.f64 z (.f64 z z))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 z x) (*.f64 (+.f64 z x) (-.f64 z x)))))
(/.f64 (fma.f64 x (.f64 x x) (.f64 z (.f64 z z))) (fma.f64 x (-.f64 x z) (.f64 z z)))
(/.f64 (fma.f64 x (.f64 x x) (.f64 z (.f64 z z))) (fma.f64 x x (-.f64 (.f64 z z) (*.f64 z x))))
(/.f64 (*.f64 (+.f64 z x) (-.f64 z x)) (-.f64 z x))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 z (.f64 z z)))) (neg.f64 (fma.f64 x (-.f64 x z) (.f64 z z))))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 z (.f64 z z)))) (neg.f64 (fma.f64 x x (-.f64 (.f64 z z) (*.f64 z x)))))
(/.f64 (neg.f64 (*.f64 (+.f64 z x) (-.f64 z x))) (neg.f64 (-.f64 z x)))
(/.f64 (-.f64 (.f64 x x) (.f64 z z)) (-.f64 x z))
(/.f64 (.f64 #s(literal 1 binary64) (fma.f64 x (.f64 x x) (.f64 z (.f64 z z)))) (fma.f64 x (-.f64 x z) (*.f64 z z)))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 (+.f64 z x) (-.f64 z x))) (-.f64 z x))
(/.f64 (neg.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 z (.f64 z z))))) (neg.f64 (neg.f64 (fma.f64 x (-.f64 x z) (.f64 z z)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 z x) (-.f64 z x)))) (neg.f64 (neg.f64 (-.f64 z x))))
(/.f64 (neg.f64 (-.f64 (.f64 x x) (.f64 z z))) (neg.f64 (-.f64 x z)))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (fma.f64 x (.f64 x x) (.f64 z (.f64 z z))))) (neg.f64 (fma.f64 x (-.f64 x z) (*.f64 z z))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (.f64 (+.f64 z x) (-.f64 z x)))) (neg.f64 (-.f64 z x)))
(pow.f64 (/.f64 (fma.f64 x (-.f64 x z) (.f64 z z)) (fma.f64 x (.f64 x x) (.f64 z (.f64 z z)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 z x) (*.f64 (+.f64 z x) (-.f64 z x))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (+.f64 z x))
(*.f64 (+.f64 z x) #s(literal 1 binary64))
(.f64 (fma.f64 x (.f64 x x) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 x (-.f64 x z) (*.f64 z z))))
(.f64 (.f64 (+.f64 z x) (-.f64 z x)) (/.f64 #s(literal 1 binary64) (-.f64 z x)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 a b)))
(+.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(-.f64 (/.f64 (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (.f64 a b)))) (/.f64 (.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))) (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 a b)))))
(-.f64 (/.f64 (.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))) (-.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))) (/.f64 (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)) (-.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))) (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (.f64 a b))) (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (*.f64 a b))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))) (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (.f64 a b))) (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (*.f64 a b)))))))
(/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 3 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))) (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64))))
(/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 3 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b)) (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 a b))))))
(/.f64 (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b)))) (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 a b))))
(/.f64 (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))) (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b)) (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 a b)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))))) (neg.f64 (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 a b)))))
(/.f64 (-.f64 (.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64))) (-.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))) (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b)))))) (neg.f64 (neg.f64 (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 a b))))))
(/.f64 (neg.f64 (-.f64 (.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)))) (neg.f64 (-.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))))
(pow.f64 (/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))) (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (.f64 a b))) (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (*.f64 a b))))) #s(literal -1 binary64))
(.f64 (fma.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) (.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 a b)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))) (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)))))
(.f64 (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 a b)) #s(approx ( (- a 1/2) b) (.f64 a b)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 a b)))))
#s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))
(+.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))
(+.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) y)
(-.f64 (/.f64 (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (neg.f64 y))) (/.f64 (.f64 y y) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (neg.f64 y))))
(-.f64 (/.f64 (.f64 y y) (-.f64 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 2 binary64)) (-.f64 y (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
(fma.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) z y)
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 y (-.f64 y (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64))) (fma.f64 y (.f64 y y) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (neg.f64 y)) (-.f64 (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (.f64 y y))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 y (-.f64 y (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64))) (fma.f64 y (.f64 y y) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (neg.f64 y)) (-.f64 (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (.f64 y y)))))
(/.f64 (fma.f64 y (.f64 y y) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64))) (fma.f64 y (-.f64 y (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64))))
(/.f64 (fma.f64 y (.f64 y y) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (.f64 z (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))))
(/.f64 (-.f64 (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (.f64 y y)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (neg.f64 y)))
(/.f64 (neg.f64 (fma.f64 y (.f64 y y) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 y (-.f64 y (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (fma.f64 y (.f64 y y) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 y y (-.f64 (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (.f64 z (*.f64 (-.f64 #s(literal 1 binary64) (log.f64 t)) y))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (.f64 y y))) (neg.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (neg.f64 y))))
(/.f64 (-.f64 (.f64 y y) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64))) (-.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 y (.f64 y y) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64))))) (neg.f64 (neg.f64 (fma.f64 y (-.f64 y (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (.f64 y y)))) (neg.f64 (neg.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (neg.f64 y)))))
(/.f64 (neg.f64 (-.f64 (.f64 y y) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)))) (neg.f64 (-.f64 y (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))))))
(pow.f64 (/.f64 (fma.f64 y (-.f64 y (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64))) (fma.f64 y (.f64 y y) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (neg.f64 y)) (-.f64 (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (.f64 y y))) #s(literal -1 binary64))
(.f64 (fma.f64 y (.f64 y y) (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)))) (pow.f64 (*.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)))))
(.f64 (-.f64 (pow.f64 (.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t))) #s(literal 2 binary64)) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (neg.f64 y))))
(+.f64 #s(literal 1 binary64) (neg.f64 (log.f64 t)))
(+.f64 (neg.f64 (log.f64 t)) #s(literal 1 binary64))
(-.f64 #s(literal 1 binary64) (log.f64 t))
(-.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64))) (/.f64 (pow.f64 (log.f64 t) #s(literal 3 binary64)) (fma.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (log.f64 t)) #s(literal 1 binary64))))
(-.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) (neg.f64 (log.f64 t)))) (/.f64 (pow.f64 (log.f64 t) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (neg.f64 (log.f64 t)))))
(fma.f64 #s(literal -1 binary64) (log.f64 t) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (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 #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 (fma.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (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 #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))) (fma.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (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) (neg.f64 (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) (neg.f64 (log.f64 t))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (log.f64 t) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (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) (neg.f64 (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) (neg.f64 (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 (fma.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (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 #s(literal 1 binary64) (log.f64 t)))))
(pow.f64 (/.f64 (fma.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (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 #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) (fma.f64 (log.f64 t) (+.f64 #s(literal 1 binary64) (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 1 binary64) (log.f64 t))))
#s(approx (* (- a 1/2) b) (*.f64 a b))
(log.f64 t)
(*.f64 #s(literal 1 binary64) (log.f64 t))
(*.f64 (log.f64 t) #s(literal 1 binary64))

eval251.0ms (1.6%)

Memory: -12.4MiB live, 466.8MiB allocated
Compiler: Compiled 41 223 to 2 794 computations (93.2% saved)

prune263.0ms (1.7%)

Memory

-2.8MiB live, 642.9MiB allocated

Pruning

32 alts after pruning (30 fresh and 2 done)

	Pruned	Kept	Total
New	1 622	15	1 637
Fresh	6	15	21
Picked	4	1	5
Done	0	1	1
Total	1 632	32	1 664

Accuracy

100.0%

Counts

1 664 → 32

Alt Table

Click to see full alt table

Status	Accuracy	Program
	62.5%	(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)))
	70.1%	(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (fma.f64 x (/.f64 y x) x))))
	43.6%	(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
	51.8%	(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
▶	76.4%	(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
	23.5%	(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))
	62.4%	(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (+ (* (log t) (neg z)) (+ x (+ y z))) (fma.f64 (log.f64 t) (neg.f64 z) z)))))
	4.1%	(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))))
	39.3%	(+.f64 (-.f64 #s(approx (+ (+ x y) z) (+.f64 z x)) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
▶	49.8%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
✓	70.0%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
	49.9%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 x (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x) x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
	63.2%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
▶	36.0%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
	36.3%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
	43.9%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (.f64 y (-.f64 (+.f64 (/.f64 x y) (+.f64 #s(literal 1 binary64) (/.f64 z y))) (/.f64 (.f64 z (log.f64 t)) y)))) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
	48.2%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (.f64 x (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) x))))) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
	40.7%	#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
	4.1%	#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
	28.7%	#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64))))
	19.7%	#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
	39.6%	#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
	24.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))
	61.4%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x)))
	71.9%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 a (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (+.f64 (+.f64 b (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 x a))) (+.f64 (/.f64 y a) (/.f64 z a))))))
▶	23.0%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
	21.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
	6.2%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64)))))
✓	27.2%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
	3.9%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
▶	2.3%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
	3.1%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))

Compiler

Compiled 1 089 to 709 computations (34.9% saved)

simplify279.0ms (1.8%)

Memory

29.9MiB live, 569.3MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 19 expressions of interest:

New	Metric	Score
cost-diff	0	(log.f64 t)
cost-diff	0	(fma.f64 (log.f64 t) (neg.f64 z) z)
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z))
cost-diff	0	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
cost-diff	0	(-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
cost-diff	0	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
cost-diff	128	(neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))
cost-diff	1024	(*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))
cost-diff	0	#s(approx (* (- a 1/2) b) #s(literal 1 binary64))
cost-diff	0	(+.f64 y x)
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x))
cost-diff	0	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
cost-diff	0	(neg.f64 x)
cost-diff	0	#s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x))
cost-diff	0	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
cost-diff	0	(+.f64 x y)
cost-diff	0	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
cost-diff	0	(fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
cost-diff	192	(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))

Rules

11 902×	`lower-fma.f32`
11 896×	`lower-fma.f64`
2 700×	`lower-+.f32`
2 690×	`lower-+.f64`
2 020×	`lower--.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	48	331
0	67	331
1	120	331
2	226	327
3	552	327
4	1524	307
5	4037	307
6	6270	307
0	8072	285

Stop Event

1×	iter limit
1×	node limit
1×	iter limit

Calls

Call 1

Inputs
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
b
a
(fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(literal -1/2 binary64)
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
x
y
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x))
(neg.f64 x)
x
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x))
(+.f64 y x)
y
x
#s(approx (* (- a 1/2) b) #s(literal 1 binary64))
#s(literal 1 binary64)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
y
#s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))
(neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))
(*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))
x
(-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))
#s(literal -1 binary64)
(/.f64 (+.f64 z #s(literal 1 binary64)) x)
(+.f64 z #s(literal 1 binary64))
z
#s(literal 1 binary64)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(log.f64 t)
t
(neg.f64 z)
z
#s(approx (* (- a 1/2) b) (*.f64 b a))
(*.f64 b a)
b
a

Outputs
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
b
a
(fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(literal -1/2 binary64)
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
x
y
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x))
(neg.f64 x)
x
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 y x)
(+.f64 x y)
y
x
#s(approx (* (- a 1/2) b) #s(literal 1 binary64))
#s(literal 1 binary64)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (+.f64 x (+.f64 z #s(literal 1 binary64))))))
(-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(-.f64 y #s(approx (log (+ 1 (+ z x))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))
y
#s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))
#s(approx (log (+ 1 (+ z x))) (+.f64 x (+.f64 z #s(literal 1 binary64))))
(neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))
(+.f64 x (+.f64 z #s(literal 1 binary64)))
(*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))
(-.f64 (-.f64 #s(literal -1 binary64) z) x)
x
(-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))
(+.f64 #s(literal -1 binary64) (/.f64 (-.f64 #s(literal -1 binary64) z) x))
#s(literal -1 binary64)
(/.f64 (+.f64 z #s(literal 1 binary64)) x)
(+.f64 z #s(literal 1 binary64))
z
#s(literal 1 binary64)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(log.f64 t)
t
(neg.f64 z)
z
#s(approx (* (- a 1/2) b) (*.f64 b a))
(*.f64 b a)
b
a

localize132.0ms (0.8%)

Memory

0.8MiB live, 200.8MiB allocated

Localize:

Found 19 expressions of interest:

New	Metric	Score
accuracy	0	(log.f64 t)
accuracy	0.140625	(fma.f64 (log.f64 t) (neg.f64 z) z)
accuracy	15.876721423227519	#s(approx (* (- a 1/2) b) (*.f64 b a))
accuracy	17.186836833586753	#s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z))
accuracy	0	(neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))
accuracy	1.4547484915700102	(*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))
accuracy	22.000589439257322	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
accuracy	29.66014949685705	#s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))
accuracy	0	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
accuracy	0	(+.f64 y x)
accuracy	13.529743194777314	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x))
accuracy	29.884035570337034	#s(approx (* (- a 1/2) b) #s(literal 1 binary64))
accuracy	0	(neg.f64 x)
accuracy	22.000589439257322	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
accuracy	27.70982498522322	#s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x))
accuracy	0	(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
accuracy	0	(fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
accuracy	0	(+.f64 x y)
accuracy	13.529743194777314	#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))

Samples

50.0ms	132×	0	invalid
27.0ms	124×	0	valid

Compiler

Compiled 234 to 37 computations (84.2% saved)

Precisions

Click to see histograms. Total time spent on operations: 52.0ms

ival-add: 24.0ms (46.1% of total)

ival-mult: 13.0ms (25% of total)

ival-sub: 4.0ms (7.7% of total)

ival-log: 3.0ms (5.8% of total)

ival-neg: 3.0ms (5.8% of total)

ival-div: 2.0ms (3.8% of total)

ival-log1p: 2.0ms (3.8% of total)

ival-assert: 0.0ms (0% of total)

ival-true: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

series495.0ms (3.2%)

Memory

-6.8MiB live, 966.9MiB allocated

Counts

21 → 852

Calls

Call 1

Inputs
#<alt (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))>
#<alt (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))>
#<alt #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))>
#<alt (+.f64 x y)>
#<alt #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))>
#<alt #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x))>
#<alt (neg.f64 x)>
#<alt (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))>
#<alt #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x))>
#<alt (+.f64 y x)>
#<alt #s(approx (* (- a 1/2) b) #s(literal 1 binary64))>
#<alt (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))>
#<alt (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))>
#<alt #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))>
#<alt (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))>
#<alt (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))>
#<alt #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z))>
#<alt (fma.f64 (log.f64 t) (neg.f64 z) z)>
#<alt (log.f64 t)>
#<alt #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))>
#<alt #s(approx (* (- a 1/2) b) (*.f64 b a))>

Outputs
#<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 (* -1 (* b (+ 1/2 (* -1 a))))>
#<alt (* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))>
#<alt (* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))>
#<alt (* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))>
#<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 (- (+ 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 (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt x>
#<alt (* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))>
#<alt (* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))>
#<alt (- (+ x (+ 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 (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt y>
#<alt (* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))>
#<alt (* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))>
#<alt y>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))>
#<alt (* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))>
#<alt (+ x (+ y (+ (* -1/2 b) (* a b))))>
#<alt (+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))>
#<alt (+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))>
#<alt (+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))>
#<alt (* z (- 1 (log t)))>
#<alt (* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))>
#<alt (* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))>
#<alt (* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))>
#<alt (* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (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 (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))>
#<alt (- (+ x (+ y (+ z (+ (* -1/2 b) (* a 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 (* -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 (- (+ 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>
#<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 (- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<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 (- y (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<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 (- y (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (* -1 (log (+ 1 (+ x z))))>
#<alt (- y (log (+ 1 (+ x z))))>
#<alt (- y (log (+ 1 (+ x z))))>
#<alt (- y (log (+ 1 (+ x z))))>
#<alt y>
#<alt (* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))>
#<alt (* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))>
#<alt (* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))>
#<alt y>
#<alt (* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))>
#<alt (* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))>
#<alt (* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))>
#<alt (- y (log (+ 1 x)))>
#<alt (- (+ y (* -1 (/ z (+ 1 x)))) (log (+ 1 x)))>
#<alt (- (+ y (* z (- (* 1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x))))) (log (+ 1 x)))>
#<alt (- (+ y (* z (- (* z (+ (* -1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x))))) (log (+ 1 x)))>
#<alt (- y (* -1 (log (/ 1 z))))>
#<alt (- (+ y (* -1 (/ (+ 1 x) z))) (* -1 (log (/ 1 z))))>
#<alt (- (+ y (* 1/2 (/ (pow (+ 1 x) 2) (pow z 2)))) (+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z))))>
#<alt (- (+ y (* -1/3 (/ (pow (+ 1 x) 3) (pow z 3)))) (+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z)))))>
#<alt (* -1 z)>
#<alt (* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))>
#<alt (* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))>
#<alt (* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))>
#<alt (- y (log (+ 1 z)))>
#<alt (- (+ y (* -1 (/ x (+ 1 z)))) (log (+ 1 z)))>
#<alt (- (+ y (* x (- (* 1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z))))) (log (+ 1 z)))>
#<alt (- (+ y (* x (- (* x (+ (* -1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z))))) (log (+ 1 z)))>
#<alt (- y (* -1 (log (/ 1 x))))>
#<alt (- (+ y (* -1 (/ (+ 1 z) x))) (* -1 (log (/ 1 x))))>
#<alt (- (+ y (* 1/2 (/ (pow (+ 1 z) 2) (pow x 2)))) (+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x))))>
#<alt (- (+ y (* -1/3 (/ (pow (+ 1 z) 3) (pow x 3)))) (+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x)))))>
#<alt (* -1 x)>
#<alt (* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))>
#<alt (* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))>
#<alt (* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) 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 (- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<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 (- y (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<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 (- y (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<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 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 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 -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 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 (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt 1>
#<alt 1>
#<alt 1>
#<alt 1>
#<alt (* -1 (+ 1 z))>
#<alt (+ (* -1 x) (* -1 (+ 1 z)))>
#<alt (+ (* -1 x) (* -1 (+ 1 z)))>
#<alt (+ (* -1 x) (* -1 (+ 1 z)))>
#<alt (* -1 x)>
#<alt (* x (- (* -1 (/ (+ 1 z) x)) 1))>
#<alt (* x (- (* -1 (/ (+ 1 z) x)) 1))>
#<alt (* x (- (* -1 (/ (+ 1 z) x)) 1))>
#<alt (* -1 x)>
#<alt (* -1 (* x (+ 1 (+ (/ 1 x) (/ z x)))))>
#<alt (* -1 (* x (+ 1 (+ (/ 1 x) (/ z x)))))>
#<alt (* -1 (* x (+ 1 (+ (/ 1 x) (/ z x)))))>
#<alt (* -1 (* x (+ 1 (/ 1 x))))>
#<alt (+ (* -1 z) (* -1 (* x (+ 1 (/ 1 x)))))>
#<alt (+ (* -1 z) (* -1 (* x (+ 1 (/ 1 x)))))>
#<alt (+ (* -1 z) (* -1 (* x (+ 1 (/ 1 x)))))>
#<alt (* -1 z)>
#<alt (* z (- (* -1 (/ (* x (+ 1 (/ 1 x))) z)) 1))>
#<alt (* z (- (* -1 (/ (* x (+ 1 (/ 1 x))) z)) 1))>
#<alt (* z (- (* -1 (/ (* x (+ 1 (/ 1 x))) z)) 1))>
#<alt (* -1 (/ z x))>
#<alt (* -1 (* z (+ (/ 1 x) (+ (/ 1 z) (/ 1 (* x z))))))>
#<alt (* -1 (* z (+ (/ 1 x) (+ (/ 1 z) (/ 1 (* x z))))))>
#<alt (* -1 (* z (+ (/ 1 x) (+ (/ 1 z) (/ 1 (* x z))))))>
#<alt (+ 1 z)>
#<alt (- x (* -1 (+ 1 z)))>
#<alt (- x (* -1 (+ 1 z)))>
#<alt (- x (* -1 (+ 1 z)))>
#<alt x>
#<alt (* x (+ 1 (+ (/ 1 x) (/ z x))))>
#<alt (* x (+ 1 (+ (/ 1 x) (/ z x))))>
#<alt (* x (+ 1 (+ (/ 1 x) (/ z x))))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))>
#<alt (* x (+ 1 (/ 1 x)))>
#<alt (- z (* -1 (* x (+ 1 (/ 1 x)))))>
#<alt (- z (* -1 (* x (+ 1 (/ 1 x)))))>
#<alt (- z (* -1 (* x (+ 1 (/ 1 x)))))>
#<alt z>
#<alt (* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z)))>
#<alt (* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z)))>
#<alt (* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z)))>
#<alt (* -1 z)>
#<alt (* -1 (* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z))))>
#<alt (* -1 (* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z))))>
#<alt (* -1 (* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z))))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<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 (- y (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<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 (- y (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (* -1 (log (+ 1 (+ x z))))>
#<alt (- y (log (+ 1 (+ x z))))>
#<alt (- y (log (+ 1 (+ x z))))>
#<alt (- y (log (+ 1 (+ x z))))>
#<alt y>
#<alt (* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))>
#<alt (* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))>
#<alt (* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))>
#<alt y>
#<alt (* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))>
#<alt (* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))>
#<alt (* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))>
#<alt (- y (log (+ 1 x)))>
#<alt (- (+ y (* -1 (/ z (+ 1 x)))) (log (+ 1 x)))>
#<alt (- (+ y (* z (- (* 1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x))))) (log (+ 1 x)))>
#<alt (- (+ y (* z (- (* z (+ (* -1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x))))) (log (+ 1 x)))>
#<alt (- y (* -1 (log (/ 1 z))))>
#<alt (- (+ y (* -1 (/ (+ 1 x) z))) (* -1 (log (/ 1 z))))>
#<alt (- (+ y (* 1/2 (/ (pow (+ 1 x) 2) (pow z 2)))) (+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z))))>
#<alt (- (+ y (* -1/3 (/ (pow (+ 1 x) 3) (pow z 3)))) (+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z)))))>
#<alt (* -1 z)>
#<alt (* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))>
#<alt (* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))>
#<alt (* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))>
#<alt (- y (log (+ 1 z)))>
#<alt (- (+ y (* -1 (/ x (+ 1 z)))) (log (+ 1 z)))>
#<alt (- (+ y (* x (- (* 1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z))))) (log (+ 1 z)))>
#<alt (- (+ y (* x (- (* x (+ (* -1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z))))) (log (+ 1 z)))>
#<alt (- y (* -1 (log (/ 1 x))))>
#<alt (- (+ y (* -1 (/ (+ 1 z) x))) (* -1 (log (/ 1 x))))>
#<alt (- (+ y (* 1/2 (/ (pow (+ 1 z) 2) (pow x 2)))) (+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x))))>
#<alt (- (+ y (* -1/3 (/ (pow (+ 1 z) 3) (pow x 3)))) (+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x)))))>
#<alt (* -1 x)>
#<alt (* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))>
#<alt (* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))>
#<alt (* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))>
#<alt (- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ a z) (+ 1/2 (* t z)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))>
#<alt (- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))>
#<alt (- (+ a y) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ 1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* b (- a 1/2))) (log (/ -1 t)))>
#<alt (- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))>
#<alt (* a b)>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<alt (* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))>
#<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 (- y (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<alt (- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))>
#<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 (- y (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<alt (- (+ y (/ 1 b)) (log (+ 1 (+ x z))))>
#<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 (+ z (* -1 (* z (log t))))>
#<alt (+ z (* -1 (* z (log t))))>
#<alt (+ z (* -1 (* z (log t))))>
#<alt (+ z (* -1 (* z (log t))))>
#<alt (+ z (* z (log (/ 1 t))))>
#<alt (+ z (* z (log (/ 1 t))))>
#<alt (+ z (* z (log (/ 1 t))))>
#<alt (+ z (* z (log (/ 1 t))))>
#<alt (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))>
#<alt (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))>
#<alt (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))>
#<alt (+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* z (+ 1 (* -1 (log t))))>
#<alt (* -1 (* z (- (log t) 1)))>
#<alt (* -1 (* z (- (log t) 1)))>
#<alt (* -1 (* z (- (log t) 1)))>
#<alt (* -1 (* z (- (log t) 1)))>
#<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 (log (+ 1 x))>
#<alt (+ (log (+ 1 x)) (/ z (+ 1 x)))>
#<alt (+ (log (+ 1 x)) (* z (+ (* -1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x)))))>
#<alt (+ (log (+ 1 x)) (* z (+ (* z (- (* 1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x)))))>
#<alt (* -1 (log (/ 1 z)))>
#<alt (+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z)))>
#<alt (+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z))))>
#<alt (+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (* 1/3 (/ (pow (+ 1 x) 3) (pow z 3))) (+ (/ 1 z) (/ x z)))))>
#<alt z>
#<alt (* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))>
#<alt (* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))>
#<alt (log (+ 1 z))>
#<alt (+ (log (+ 1 z)) (/ x (+ 1 z)))>
#<alt (+ (log (+ 1 z)) (* x (+ (* -1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z)))))>
#<alt (+ (log (+ 1 z)) (* x (+ (* x (- (* 1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z)))))>
#<alt (* -1 (log (/ 1 x)))>
#<alt (+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x)))>
#<alt (+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x))))>
#<alt (+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (* 1/3 (/ (pow (+ 1 z) 3) (pow x 3))) (+ (/ 1 x) (/ z x)))))>
#<alt x>
#<alt (* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))>
#<alt (* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))>
#<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 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 (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (- a 1/2)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt (/ 1 b)>
#<alt 1>
#<alt 1>
#<alt 1>
#<alt 1>

Calls

213 calls:

Time	Variable		Point	Expression
24.0ms	t	@	0	(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
20.0ms	b	@	-inf	(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
14.0ms	t	@	0	(- (+ (+ x y) z) (* z (log t)))
9.0ms	t	@	0	(+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b))
9.0ms	z	@	0	(+ (* (log t) (neg z)) z)

simplify398.0ms (2.6%)

Memory

6.6MiB live, 672.3MiB allocated

Algorithm

1×	egg-herbie

Rules

8 850×	`lower-fma.f64`
8 850×	`lower-fma.f32`
5 272×	`lower-+.f64`
5 272×	`lower-+.f32`
4 888×	`lower-*.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	645	12257
1	1976	12000
2	6286	11909
0	8053	11136

Stop Event

1×	iter limit
1×	node limit

Counts

852 → 809

Calls

Call 1

Inputs
(- (+ 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))))
(* -1 (* b (+ 1/2 (* -1 a))))
(* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))
(* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))
(* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))
(- (+ 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)))))
(- (+ 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)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
x
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))
x
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))
(- (+ x (+ 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)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
y
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))
y
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))
(+ x (+ y (+ (* -1/2 b) (* a b))))
(+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))
(+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))
(+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))
(* z (- 1 (log t)))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))
(* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (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)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a 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 (* -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))))))
(- (+ 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
(+ 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)))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a y) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* 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)))))
(- y (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(* 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))))
(- y (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(* -1 (log (+ 1 (+ x z))))
(- y (log (+ 1 (+ x z))))
(- y (log (+ 1 (+ x z))))
(- y (log (+ 1 (+ x z))))
y
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
y
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(- y (log (+ 1 x)))
(- (+ y (* -1 (/ z (+ 1 x)))) (log (+ 1 x)))
(- (+ y (* z (- (* 1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x))))) (log (+ 1 x)))
(- (+ y (* z (- (* z (+ (* -1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x))))) (log (+ 1 x)))
(- y (* -1 (log (/ 1 z))))
(- (+ y (* -1 (/ (+ 1 x) z))) (* -1 (log (/ 1 z))))
(- (+ y (* 1/2 (/ (pow (+ 1 x) 2) (pow z 2)))) (+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z))))
(- (+ y (* -1/3 (/ (pow (+ 1 x) 3) (pow z 3)))) (+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z)))))
(* -1 z)
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(- y (log (+ 1 z)))
(- (+ y (* -1 (/ x (+ 1 z)))) (log (+ 1 z)))
(- (+ y (* x (- (* 1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z))))) (log (+ 1 z)))
(- (+ y (* x (- (* x (+ (* -1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z))))) (log (+ 1 z)))
(- y (* -1 (log (/ 1 x))))
(- (+ y (* -1 (/ (+ 1 z) x))) (* -1 (log (/ 1 x))))
(- (+ y (* 1/2 (/ (pow (+ 1 z) 2) (pow x 2)))) (+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x))))
(- (+ y (* -1/3 (/ (pow (+ 1 z) 3) (pow x 3)))) (+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x)))))
(* -1 x)
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) 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)
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a y) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* 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)))))
(- y (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(* 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))))
(- y (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ 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))))))
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)))
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)))
-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 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)))))
(- a 1/2)
(- a 1/2)
(- a 1/2)
(- a 1/2)
(/ 1 b)
(/ 1 b)
(/ 1 b)
(/ 1 b)
1
1
1
1
(* -1 (+ 1 z))
(+ (* -1 x) (* -1 (+ 1 z)))
(+ (* -1 x) (* -1 (+ 1 z)))
(+ (* -1 x) (* -1 (+ 1 z)))
(* -1 x)
(* x (- (* -1 (/ (+ 1 z) x)) 1))
(* x (- (* -1 (/ (+ 1 z) x)) 1))
(* x (- (* -1 (/ (+ 1 z) x)) 1))
(* -1 x)
(* -1 (* x (+ 1 (+ (/ 1 x) (/ z x)))))
(* -1 (* x (+ 1 (+ (/ 1 x) (/ z x)))))
(* -1 (* x (+ 1 (+ (/ 1 x) (/ z x)))))
(* -1 (* x (+ 1 (/ 1 x))))
(+ (* -1 z) (* -1 (* x (+ 1 (/ 1 x)))))
(+ (* -1 z) (* -1 (* x (+ 1 (/ 1 x)))))
(+ (* -1 z) (* -1 (* x (+ 1 (/ 1 x)))))
(* -1 z)
(* z (- (* -1 (/ (* x (+ 1 (/ 1 x))) z)) 1))
(* z (- (* -1 (/ (* x (+ 1 (/ 1 x))) z)) 1))
(* z (- (* -1 (/ (* x (+ 1 (/ 1 x))) z)) 1))
(* -1 (/ z x))
(* -1 (* z (+ (/ 1 x) (+ (/ 1 z) (/ 1 (* x z))))))
(* -1 (* z (+ (/ 1 x) (+ (/ 1 z) (/ 1 (* x z))))))
(* -1 (* z (+ (/ 1 x) (+ (/ 1 z) (/ 1 (* x z))))))
(+ 1 z)
(- x (* -1 (+ 1 z)))
(- x (* -1 (+ 1 z)))
(- x (* -1 (+ 1 z)))
x
(* x (+ 1 (+ (/ 1 x) (/ z x))))
(* x (+ 1 (+ (/ 1 x) (/ z x))))
(* x (+ 1 (+ (/ 1 x) (/ z x))))
x
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(* x (+ 1 (/ 1 x)))
(- z (* -1 (* x (+ 1 (/ 1 x)))))
(- z (* -1 (* x (+ 1 (/ 1 x)))))
(- z (* -1 (* x (+ 1 (/ 1 x)))))
z
(* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z)))
(* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z)))
(* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z)))
(* -1 z)
(* -1 (* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z))))
(* -1 (* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z))))
(* -1 (* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z))))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a y) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* 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)))))
(- y (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(* 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))))
(- y (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(* -1 (log (+ 1 (+ x z))))
(- y (log (+ 1 (+ x z))))
(- y (log (+ 1 (+ x z))))
(- y (log (+ 1 (+ x z))))
y
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
y
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(- y (log (+ 1 x)))
(- (+ y (* -1 (/ z (+ 1 x)))) (log (+ 1 x)))
(- (+ y (* z (- (* 1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x))))) (log (+ 1 x)))
(- (+ y (* z (- (* z (+ (* -1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x))))) (log (+ 1 x)))
(- y (* -1 (log (/ 1 z))))
(- (+ y (* -1 (/ (+ 1 x) z))) (* -1 (log (/ 1 z))))
(- (+ y (* 1/2 (/ (pow (+ 1 x) 2) (pow z 2)))) (+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z))))
(- (+ y (* -1/3 (/ (pow (+ 1 x) 3) (pow z 3)))) (+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z)))))
(* -1 z)
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(- y (log (+ 1 z)))
(- (+ y (* -1 (/ x (+ 1 z)))) (log (+ 1 z)))
(- (+ y (* x (- (* 1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z))))) (log (+ 1 z)))
(- (+ y (* x (- (* x (+ (* -1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z))))) (log (+ 1 z)))
(- y (* -1 (log (/ 1 x))))
(- (+ y (* -1 (/ (+ 1 z) x))) (* -1 (log (/ 1 x))))
(- (+ y (* 1/2 (/ (pow (+ 1 z) 2) (pow x 2)))) (+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x))))
(- (+ y (* -1/3 (/ (pow (+ 1 z) 3) (pow x 3)))) (+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x)))))
(* -1 x)
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ a z) (+ 1/2 (* t z)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(- (+ a y) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(* a b)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(* 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)))))
(- y (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(* 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))))
(- y (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(- (+ 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))))))
(+ z (* -1 (* z (log t))))
(+ z (* -1 (* z (log t))))
(+ z (* -1 (* z (log t))))
(+ z (* -1 (* z (log t))))
(+ z (* z (log (/ 1 t))))
(+ z (* z (log (/ 1 t))))
(+ z (* z (log (/ 1 t))))
(+ z (* z (log (/ 1 t))))
(+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(* z (+ 1 (* -1 (log t))))
(* z (+ 1 (* -1 (log t))))
(* z (+ 1 (* -1 (log t))))
(* z (+ 1 (* -1 (log t))))
(* z (+ 1 (* -1 (log t))))
(* z (+ 1 (* -1 (log t))))
(* z (+ 1 (* -1 (log t))))
(* z (+ 1 (* -1 (log t))))
(* -1 (* z (- (log t) 1)))
(* -1 (* z (- (log t) 1)))
(* -1 (* z (- (log t) 1)))
(* -1 (* z (- (log t) 1)))
(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))))
(log (+ 1 x))
(+ (log (+ 1 x)) (/ z (+ 1 x)))
(+ (log (+ 1 x)) (* z (+ (* -1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x)))))
(+ (log (+ 1 x)) (* z (+ (* z (- (* 1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x)))))
(* -1 (log (/ 1 z)))
(+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z)))
(+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z))))
(+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (* 1/3 (/ (pow (+ 1 x) 3) (pow z 3))) (+ (/ 1 z) (/ x z)))))
z
(* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))
(log (+ 1 z))
(+ (log (+ 1 z)) (/ x (+ 1 z)))
(+ (log (+ 1 z)) (* x (+ (* -1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z)))))
(+ (log (+ 1 z)) (* x (+ (* x (- (* 1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z)))))
(* -1 (log (/ 1 x)))
(+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x)))
(+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x))))
(+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (* 1/3 (/ (pow (+ 1 z) 3) (pow x 3))) (+ (/ 1 x) (/ z x)))))
x
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
-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 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)))))
(- a 1/2)
(- a 1/2)
(- a 1/2)
(- a 1/2)
(/ 1 b)
(/ 1 b)
(/ 1 b)
(/ 1 b)
1
1
1
1

Outputs
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (* b (- a 1/2))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(* 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 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* -1 (* b (+ 1/2 (* -1 a))))
(neg.f64 (*.f64 b (-.f64 #s(literal 1/2 binary64) a)))
(* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))
(*.f64 (-.f64 (-.f64 #s(literal 1/2 binary64) a) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y)) b)) (neg.f64 b))
(* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))
(*.f64 (-.f64 (-.f64 #s(literal 1/2 binary64) a) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y)) b)) (neg.f64 b))
(* -1 (* b (+ 1/2 (+ (* -1 a) (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b))))))
(*.f64 (-.f64 (-.f64 #s(literal 1/2 binary64) a) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y)) b)) (neg.f64 b))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b) (/.f64 x a)) (+.f64 (/.f64 y a) (/.f64 z a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b) (/.f64 x a)) (+.f64 (/.f64 y a) (/.f64 z a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ x a) (+ (/ y a) (/ z a))))) (/ (* z (log t)) a)))
(*.f64 a (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) b) (/.f64 x a)) (+.f64 (/.f64 y a) (/.f64 z a)))))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t)))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
x
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))
(+.f64 x (.f64 x (-.f64 (+.f64 (fma.f64 b (/.f64 a x) (/.f64 z x)) (fma.f64 b (/.f64 #s(literal -1/2 binary64) x) (/.f64 y x))) (/.f64 (.f64 z (log.f64 t)) x))))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))
(+.f64 x (.f64 x (-.f64 (+.f64 (fma.f64 b (/.f64 a x) (/.f64 z x)) (fma.f64 b (/.f64 #s(literal -1/2 binary64) x) (/.f64 y x))) (/.f64 (.f64 z (log.f64 t)) x))))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (+ (/ z x) (/ (* a b) x))))) (/ (* z (log t)) x)))
(+.f64 x (.f64 x (-.f64 (+.f64 (fma.f64 b (/.f64 a x) (/.f64 z x)) (fma.f64 b (/.f64 #s(literal -1/2 binary64) x) (/.f64 y x))) (/.f64 (.f64 z (log.f64 t)) x))))
x
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) x)) (neg.f64 x))
(- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (-.f64 z (*.f64 z (log.f64 t)))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
y
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) y) (+.f64 (/.f64 x y) (fma.f64 b (/.f64 a y) (/.f64 z y)))) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) y) (+.f64 (/.f64 x y) (fma.f64 b (/.f64 a y) (/.f64 z y)))) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (+ (/ z y) (/ (* a b) y))))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) y) (+.f64 (/.f64 x y) (fma.f64 b (/.f64 a y) (/.f64 z y)))) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
y
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))
(.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (-.f64 z (.f64 z (log.f64 t))))) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))
(.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (-.f64 z (.f64 z (log.f64 t))))) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (+ (* -1/2 b) (* a b)))) (* z (log t))) y)) 1)))
(.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (-.f64 z (.f64 z (log.f64 t))))) y)) (neg.f64 y))
(+ x (+ y (+ (* -1/2 b) (* a b))))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y))
(+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(+ x (+ y (+ (* -1/2 b) (+ (* a b) (* z (- 1 (log t)))))))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(* z (- 1 (log t)))
(-.f64 z (*.f64 z (log.f64 t)))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) z) (/.f64 x z)) (-.f64 (fma.f64 b (/.f64 a z) (/.f64 y z)) (log.f64 t)))))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) z) (/.f64 x z)) (-.f64 (fma.f64 b (/.f64 a z) (/.f64 y z)) (log.f64 t)))))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (+ (/ y z) (/ (* a b) z))))) (log t)))
(*.f64 z (+.f64 #s(literal 1 binary64) (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) z) (/.f64 x z)) (-.f64 (fma.f64 b (/.f64 a z) (/.f64 y z)) (log.f64 t)))))
(* z (+ 1 (* -1 (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x (+ y (+ (* -1/2 b) (* a b)))) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) z)) (neg.f64 z))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (log t)))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* -1 (* z (log (/ 1 t)))))
(+.f64 x (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 x (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 x (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 x (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))))
(- (+ x (+ y (+ z (+ (* -1/2 b) (* a b))))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 x (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ (/ x b) (+ (/ y b) (/ z b))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (/.f64 x b) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* -1/2 b)
(*.f64 b #s(literal -1/2 binary64))
(* -1 (* b (+ 1/2 (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 (neg.f64 b) (-.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y)) b)))
(* -1 (* b (+ 1/2 (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 (neg.f64 b) (-.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y)) b)))
(* -1 (* b (+ 1/2 (* -1 (/ (- (+ x (+ y z)) (* z (log t))) b)))))
(*.f64 (neg.f64 b) (-.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y)) b)))
(- (+ y (+ z (* -1/2 b))) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
x
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (/ z x)))) (/ (* z (log t)) x)))
(+.f64 x (.f64 x (-.f64 (+.f64 (/.f64 z x) (fma.f64 b (/.f64 #s(literal -1/2 binary64) x) (/.f64 y x))) (/.f64 (.f64 z (log.f64 t)) x))))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (/ z x)))) (/ (* z (log t)) x)))
(+.f64 x (.f64 x (-.f64 (+.f64 (/.f64 z x) (fma.f64 b (/.f64 #s(literal -1/2 binary64) x) (/.f64 y x))) (/.f64 (.f64 z (log.f64 t)) x))))
(* x (- (+ 1 (+ (* -1/2 (/ b x)) (+ (/ y x) (/ z x)))) (/ (* z (log t)) x)))
(+.f64 x (.f64 x (-.f64 (+.f64 (/.f64 z x) (fma.f64 b (/.f64 #s(literal -1/2 binary64) x) (/.f64 y x))) (/.f64 (.f64 z (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 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* -1/2 b))) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y (+ z (* -1/2 b))) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)) x)) (neg.f64 x))
(- (+ x (+ z (* -1/2 b))) (* z (log t)))
(+.f64 (fma.f64 b #s(literal -1/2 binary64) z) (-.f64 x (*.f64 z (log.f64 t))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
y
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (/ z y)))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) y) (/.f64 z y)) (/.f64 x y)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (/ z y)))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) y) (/.f64 z y)) (/.f64 x y)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (* -1/2 (/ b y)) (+ (/ x y) (/ z y)))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) y) (/.f64 z y)) (/.f64 x y)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (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 (fma.f64 b #s(literal -1/2 binary64) z) (-.f64 x (.f64 z (log.f64 t)))) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* -1/2 b))) (* z (log t))) y)) 1)))
(.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (fma.f64 b #s(literal -1/2 binary64) z) (-.f64 x (.f64 z (log.f64 t)))) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x (+ z (* -1/2 b))) (* z (log t))) y)) 1)))
(.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 (fma.f64 b #s(literal -1/2 binary64) z) (-.f64 x (.f64 z (log.f64 t)))) y)) (neg.f64 y))
(+ x (+ y (* -1/2 b)))
(+.f64 x (fma.f64 b #s(literal -1/2 binary64) y))
(+ x (+ y (+ (* -1/2 b) (* z (- 1 (log t))))))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(+ x (+ y (+ (* -1/2 b) (* z (- 1 (log t))))))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(+ x (+ y (+ (* -1/2 b) (* z (- 1 (log t))))))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(* z (- 1 (log t)))
(-.f64 z (*.f64 z (log.f64 t)))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (/ y z)))) (log t)))
(+.f64 z (*.f64 z (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) z) (/.f64 x z)) (-.f64 (/.f64 y z) (log.f64 t)))))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (/ y z)))) (log t)))
(+.f64 z (*.f64 z (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) z) (/.f64 x z)) (-.f64 (/.f64 y z) (log.f64 t)))))
(* z (- (+ 1 (+ (* -1/2 (/ b z)) (+ (/ x z) (/ y z)))) (log t)))
(+.f64 z (*.f64 z (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) z) (/.f64 x z)) (-.f64 (/.f64 y z) (log.f64 t)))))
(* z (+ 1 (* -1 (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* -1/2 b))) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 x (fma.f64 b #s(literal -1/2 binary64) y)) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* -1/2 b))) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 x (fma.f64 b #s(literal -1/2 binary64) y)) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x (+ y (* -1/2 b))) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 x (fma.f64 b #s(literal -1/2 binary64) y)) z)) (neg.f64 z))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t)))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* -1 (* z (log (/ 1 t)))))
(+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y)))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 x (+.f64 z (fma.f64 b #s(literal -1/2 binary64) y))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 x (+.f64 z (fma.f64 b #s(literal -1/2 binary64) y))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 x (+.f64 z (fma.f64 b #s(literal -1/2 binary64) y))))
(- (+ x (+ y (+ z (* -1/2 b)))) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) (+.f64 x (+.f64 z (fma.f64 b #s(literal -1/2 binary64) y))))
(- (+ y z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
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 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(- (+ x z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
y
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(+ x y)
(+.f64 x y)
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(* z (- 1 (log t)))
(-.f64 z (*.f64 z (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 z (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 x y) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 x y) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 x y) z)) (neg.f64 z))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x y) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x y) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x y) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x y) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z))
y
(+ x y)
(+.f64 x y)
(+ x y)
(+.f64 x y)
(+ x y)
(+.f64 x y)
x
(* x (+ 1 (/ y x)))
(fma.f64 #s(literal 1 binary64) (/.f64 y #s(literal 1 binary64)) x)
(* x (+ 1 (/ y x)))
(fma.f64 #s(literal 1 binary64) (/.f64 y #s(literal 1 binary64)) x)
(* x (+ 1 (/ y x)))
(fma.f64 #s(literal 1 binary64) (/.f64 y #s(literal 1 binary64)) x)
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 y x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 y x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 y x)) (neg.f64 x))
x
(+ x y)
(+.f64 x y)
(+ x y)
(+.f64 x y)
(+ x y)
(+.f64 x y)
y
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 x y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 x y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 x y)) (neg.f64 y))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 x (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 x (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(-.f64 (-.f64 (-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (.f64 x (.f64 x x)) (.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 z (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y y) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y y) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (-.f64 z (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 y (.f64 y y)) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(-.f64 (-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 z (*.f64 z z))))))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 a (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 a (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 a (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 b #s(literal -1/2 binary64) y) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 z #s(literal -1/2 binary64))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (+.f64 x (+.f64 z #s(literal -1/2 binary64))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (fma.f64 #s(literal -1/3 binary64) (/.f64 a (.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(*.f64 a (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (-.f64 b (/.f64 (log.f64 a) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a))) (-.f64 b (/.f64 (log.f64 a) a))) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (.f64 a a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (+.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (/.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (.f64 a (.f64 a a)))) (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a)))) (-.f64 b (/.f64 (log.f64 a) a))) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (*.f64 a a)))))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(- y (log (- (+ a (+ x z)) 1/2)))
(-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(* 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 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 x z)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 x z)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 x z)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 x z)))
(* -1 (log (+ 1 (+ x z))))
(neg.f64 (log1p.f64 (+.f64 x z)))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 x z)))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 x z)))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 x z)))
y
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(fma.f64 y (/.f64 (log1p.f64 (+.f64 x z)) (neg.f64 y)) y)
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(fma.f64 y (/.f64 (log1p.f64 (+.f64 x z)) (neg.f64 y)) y)
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(fma.f64 y (/.f64 (log1p.f64 (+.f64 x z)) (neg.f64 y)) y)
y
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(neg.f64 (fma.f64 y (/.f64 (log1p.f64 (+.f64 x z)) y) (neg.f64 y)))
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(neg.f64 (fma.f64 y (/.f64 (log1p.f64 (+.f64 x z)) y) (neg.f64 y)))
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(neg.f64 (fma.f64 y (/.f64 (log1p.f64 (+.f64 x z)) y) (neg.f64 y)))
(- y (log (+ 1 x)))
(-.f64 y (log1p.f64 x))
(- (+ y (* -1 (/ z (+ 1 x)))) (log (+ 1 x)))
(+.f64 (/.f64 z (-.f64 #s(literal -1 binary64) x)) (-.f64 y (log1p.f64 x)))
(- (+ y (* z (- (* 1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x))))) (log (+ 1 x)))
(fma.f64 z (fma.f64 z (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64)))) (/.f64 #s(literal -1 binary64) (+.f64 x #s(literal 1 binary64)))) (-.f64 y (log1p.f64 x)))
(- (+ y (* z (- (* z (+ (* -1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x))))) (log (+ 1 x)))
(fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 x #s(literal 1 binary64)) (.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 x #s(literal 1 binary64)))) (-.f64 y (log1p.f64 x)))
(- y (* -1 (log (/ 1 z))))
(-.f64 y (log.f64 z))
(- (+ y (* -1 (/ (+ 1 x) z))) (* -1 (log (/ 1 z))))
(+.f64 (/.f64 (-.f64 #s(literal -1 binary64) x) z) (-.f64 y (log.f64 z)))
(- (+ y (* 1/2 (/ (pow (+ 1 x) 2) (pow z 2)))) (+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64))) (.f64 z z)) y) (+.f64 (/.f64 x z) (+.f64 (/.f64 #s(literal 1 binary64) z) (log.f64 z))))
(- (+ y (* -1/3 (/ (pow (+ 1 x) 3) (pow z 3)))) (+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z)))))
(-.f64 (fma.f64 #s(literal -1/3 binary64) (/.f64 (.f64 (+.f64 x #s(literal 1 binary64)) (.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64)))) (.f64 z (.f64 z z))) (-.f64 y (log.f64 z))) (+.f64 (/.f64 x z) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64))) (.f64 z z)) (/.f64 #s(literal 1 binary64) z))))
(* -1 z)
(neg.f64 z)
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(neg.f64 (fma.f64 (neg.f64 z) (/.f64 (+.f64 y (-.f64 #s(literal -1 binary64) x)) z) z))
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(neg.f64 (fma.f64 (neg.f64 z) (/.f64 (+.f64 y (-.f64 #s(literal -1 binary64) x)) z) z))
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(neg.f64 (fma.f64 (neg.f64 z) (/.f64 (+.f64 y (-.f64 #s(literal -1 binary64) x)) z) z))
(- y (log (+ 1 z)))
(-.f64 y (log1p.f64 z))
(- (+ y (* -1 (/ x (+ 1 z)))) (log (+ 1 z)))
(+.f64 y (-.f64 (/.f64 x (-.f64 #s(literal -1 binary64) z)) (log1p.f64 z)))
(- (+ y (* x (- (* 1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z))))) (log (+ 1 z)))
(fma.f64 x (fma.f64 x (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (/.f64 #s(literal -1 binary64) (+.f64 z #s(literal 1 binary64)))) (-.f64 y (log1p.f64 z)))
(- (+ y (* x (- (* x (+ (* -1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z))))) (log (+ 1 z)))
(fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z #s(literal 1 binary64)))) (-.f64 y (log1p.f64 z)))
(- y (* -1 (log (/ 1 x))))
(-.f64 y (log.f64 x))
(- (+ y (* -1 (/ (+ 1 z) x))) (* -1 (log (/ 1 x))))
(+.f64 (/.f64 (-.f64 #s(literal -1 binary64) z) x) (-.f64 y (log.f64 x)))
(- (+ y (* 1/2 (/ (pow (+ 1 z) 2) (pow x 2)))) (+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x x)) (-.f64 y (+.f64 (log.f64 x) (+.f64 (/.f64 z x) (/.f64 #s(literal 1 binary64) x)))))
(- (+ y (* -1/3 (/ (pow (+ 1 z) 3) (pow x 3)))) (+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x)))))
(-.f64 (fma.f64 #s(literal -1/3 binary64) (.f64 (+.f64 z #s(literal 1 binary64)) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x (.f64 x x)))) y) (+.f64 (log.f64 x) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x x)) (+.f64 (/.f64 z x) (/.f64 #s(literal 1 binary64) x)))))
(* -1 x)
(neg.f64 x)
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(neg.f64 (fma.f64 x (/.f64 (-.f64 y (+.f64 z #s(literal 1 binary64))) (neg.f64 x)) x))
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(neg.f64 (fma.f64 x (/.f64 (-.f64 y (+.f64 z #s(literal 1 binary64))) (neg.f64 x)) x))
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(neg.f64 (fma.f64 x (/.f64 (-.f64 y (+.f64 z #s(literal 1 binary64))) (neg.f64 x)) x))
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(* -1 x)
(neg.f64 x)
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 x (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 x (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(-.f64 (-.f64 (-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (.f64 x (.f64 x x)) (.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 z (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y y) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y y) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (-.f64 z (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 y (.f64 y y)) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(-.f64 (-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 z (*.f64 z z))))))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 a (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 a (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 a (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 b #s(literal -1/2 binary64) y) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 z #s(literal -1/2 binary64))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (+.f64 x (+.f64 z #s(literal -1/2 binary64))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (fma.f64 #s(literal -1/3 binary64) (/.f64 a (.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(*.f64 a (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (-.f64 b (/.f64 (log.f64 a) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a))) (-.f64 b (/.f64 (log.f64 a) a))) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (.f64 a a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (+.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (/.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (.f64 a (.f64 a a)))) (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a)))) (-.f64 b (/.f64 (log.f64 a) a))) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (*.f64 a a)))))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(- y (log (- (+ a (+ x z)) 1/2)))
(-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(* 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 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 x z)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 x z)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 x z)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 x z)))
(- (+ y z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
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 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(- (+ x z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
y
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(+ x y)
(+.f64 x y)
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(* z (- 1 (log t)))
(-.f64 z (*.f64 z (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 z (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 x y) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 x y) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 x y) z)) (neg.f64 z))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x y) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x y) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x y) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x y) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z))
x
(+ x y)
(+.f64 x y)
(+ x y)
(+.f64 x y)
(+ x y)
(+.f64 x y)
y
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
(* y (+ 1 (/ x y)))
(fma.f64 y (/.f64 x y) y)
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 x y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 x y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 x y)) (neg.f64 y))
y
(+ x y)
(+.f64 x y)
(+ x y)
(+.f64 x y)
(+ x y)
(+.f64 x y)
x
(* x (+ 1 (/ y x)))
(fma.f64 #s(literal 1 binary64) (/.f64 y #s(literal 1 binary64)) x)
(* x (+ 1 (/ y x)))
(fma.f64 #s(literal 1 binary64) (/.f64 y #s(literal 1 binary64)) x)
(* x (+ 1 (/ y x)))
(fma.f64 #s(literal 1 binary64) (/.f64 y #s(literal 1 binary64)) x)
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 y x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 y x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 y x)) (neg.f64 x))
-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 b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(.f64 (neg.f64 a) (-.f64 (/.f64 (.f64 b #s(literal 1/2 binary64)) a) b))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(.f64 (neg.f64 a) (-.f64 (/.f64 (.f64 b #s(literal 1/2 binary64)) a) b))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(.f64 (neg.f64 a) (-.f64 (/.f64 (.f64 b #s(literal 1/2 binary64)) a) b))
(- 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 1/2)
(+.f64 a #s(literal -1/2 binary64))
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
(* -1 (+ 1 z))
(-.f64 #s(literal -1 binary64) z)
(+ (* -1 x) (* -1 (+ 1 z)))
(-.f64 (-.f64 #s(literal -1 binary64) z) x)
(+ (* -1 x) (* -1 (+ 1 z)))
(-.f64 (-.f64 #s(literal -1 binary64) z) x)
(+ (* -1 x) (* -1 (+ 1 z)))
(-.f64 (-.f64 #s(literal -1 binary64) z) x)
(* -1 x)
(neg.f64 x)
(* x (- (* -1 (/ (+ 1 z) x)) 1))
(fma.f64 x (/.f64 (-.f64 #s(literal -1 binary64) z) x) (neg.f64 x))
(* x (- (* -1 (/ (+ 1 z) x)) 1))
(fma.f64 x (/.f64 (-.f64 #s(literal -1 binary64) z) x) (neg.f64 x))
(* x (- (* -1 (/ (+ 1 z) x)) 1))
(fma.f64 x (/.f64 (-.f64 #s(literal -1 binary64) z) x) (neg.f64 x))
(* -1 x)
(neg.f64 x)
(* -1 (* x (+ 1 (+ (/ 1 x) (/ z x)))))
(-.f64 (neg.f64 x) (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))
(* -1 (* x (+ 1 (+ (/ 1 x) (/ z x)))))
(-.f64 (neg.f64 x) (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))
(* -1 (* x (+ 1 (+ (/ 1 x) (/ z x)))))
(-.f64 (neg.f64 x) (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))
(* -1 (* x (+ 1 (/ 1 x))))
(-.f64 #s(literal -1 binary64) x)
(+ (* -1 z) (* -1 (* x (+ 1 (/ 1 x)))))
(-.f64 (-.f64 #s(literal -1 binary64) z) x)
(+ (* -1 z) (* -1 (* x (+ 1 (/ 1 x)))))
(-.f64 (-.f64 #s(literal -1 binary64) z) x)
(+ (* -1 z) (* -1 (* x (+ 1 (/ 1 x)))))
(-.f64 (-.f64 #s(literal -1 binary64) z) x)
(* -1 z)
(neg.f64 z)
(* z (- (* -1 (/ (* x (+ 1 (/ 1 x))) z)) 1))
(fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))
(* z (- (* -1 (/ (* x (+ 1 (/ 1 x))) z)) 1))
(fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))
(* z (- (* -1 (/ (* x (+ 1 (/ 1 x))) z)) 1))
(fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))
(* -1 (/ z x))
(/.f64 z (neg.f64 x))
(* -1 (* z (+ (/ 1 x) (+ (/ 1 z) (/ 1 (* x z))))))
(neg.f64 (fma.f64 z (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 #s(literal 1 binary64) (*.f64 x z))) (/.f64 z x)))
(* -1 (* z (+ (/ 1 x) (+ (/ 1 z) (/ 1 (* x z))))))
(neg.f64 (fma.f64 z (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 #s(literal 1 binary64) (*.f64 x z))) (/.f64 z x)))
(* -1 (* z (+ (/ 1 x) (+ (/ 1 z) (/ 1 (* x z))))))
(neg.f64 (fma.f64 z (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 #s(literal 1 binary64) (*.f64 x z))) (/.f64 z x)))
(+ 1 z)
(+.f64 z #s(literal 1 binary64))
(- x (* -1 (+ 1 z)))
(+.f64 x (+.f64 z #s(literal 1 binary64)))
(- x (* -1 (+ 1 z)))
(+.f64 x (+.f64 z #s(literal 1 binary64)))
(- x (* -1 (+ 1 z)))
(+.f64 x (+.f64 z #s(literal 1 binary64)))
x
(* x (+ 1 (+ (/ 1 x) (/ z x))))
(+.f64 x (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))
(* x (+ 1 (+ (/ 1 x) (/ z x))))
(+.f64 x (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))
(* x (+ 1 (+ (/ 1 x) (/ z x))))
(+.f64 x (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))
x
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(neg.f64 (fma.f64 x (/.f64 (-.f64 #s(literal -1 binary64) z) x) (neg.f64 x)))
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(neg.f64 (fma.f64 x (/.f64 (-.f64 #s(literal -1 binary64) z) x) (neg.f64 x)))
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(neg.f64 (fma.f64 x (/.f64 (-.f64 #s(literal -1 binary64) z) x) (neg.f64 x)))
(* x (+ 1 (/ 1 x)))
(+.f64 x #s(literal 1 binary64))
(- z (* -1 (* x (+ 1 (/ 1 x)))))
(+.f64 x (+.f64 z #s(literal 1 binary64)))
(- z (* -1 (* x (+ 1 (/ 1 x)))))
(+.f64 x (+.f64 z #s(literal 1 binary64)))
(- z (* -1 (* x (+ 1 (/ 1 x)))))
(+.f64 x (+.f64 z #s(literal 1 binary64)))
z
(* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z)))
(fma.f64 z (/.f64 (+.f64 x #s(literal 1 binary64)) z) z)
(* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z)))
(fma.f64 z (/.f64 (+.f64 x #s(literal 1 binary64)) z) z)
(* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z)))
(fma.f64 z (/.f64 (+.f64 x #s(literal 1 binary64)) z) z)
(* -1 z)
(neg.f64 z)
(* -1 (* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z))))
(fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))
(* -1 (* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z))))
(fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))
(* -1 (* z (+ 1 (/ (* x (+ 1 (/ 1 x))) z))))
(fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 x (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 x (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(-.f64 (-.f64 (-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (.f64 x (.f64 x x)) (.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 z (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y y) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y y) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (-.f64 z (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 y (.f64 y y)) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(-.f64 (-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 z (*.f64 z z))))))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 a (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 a (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 a (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 b #s(literal -1/2 binary64) y) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 z #s(literal -1/2 binary64))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (+.f64 x (+.f64 z #s(literal -1/2 binary64))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (fma.f64 #s(literal -1/3 binary64) (/.f64 a (.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(*.f64 a (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (-.f64 b (/.f64 (log.f64 a) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a))) (-.f64 b (/.f64 (log.f64 a) a))) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (.f64 a a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (+.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (/.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (.f64 a (.f64 a a)))) (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a)))) (-.f64 b (/.f64 (log.f64 a) a))) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (*.f64 a a)))))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(- y (log (- (+ a (+ x z)) 1/2)))
(-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(* 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 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 x z)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 x z)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 x z)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 x z)))
(* -1 (log (+ 1 (+ x z))))
(neg.f64 (log1p.f64 (+.f64 x z)))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 x z)))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 x z)))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 x z)))
y
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(fma.f64 y (/.f64 (log1p.f64 (+.f64 x z)) (neg.f64 y)) y)
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(fma.f64 y (/.f64 (log1p.f64 (+.f64 x z)) (neg.f64 y)) y)
(* y (+ 1 (* -1 (/ (log (+ 1 (+ x z))) y))))
(fma.f64 y (/.f64 (log1p.f64 (+.f64 x z)) (neg.f64 y)) y)
y
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(neg.f64 (fma.f64 y (/.f64 (log1p.f64 (+.f64 x z)) y) (neg.f64 y)))
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(neg.f64 (fma.f64 y (/.f64 (log1p.f64 (+.f64 x z)) y) (neg.f64 y)))
(* -1 (* y (- (/ (log (+ 1 (+ x z))) y) 1)))
(neg.f64 (fma.f64 y (/.f64 (log1p.f64 (+.f64 x z)) y) (neg.f64 y)))
(- y (log (+ 1 x)))
(-.f64 y (log1p.f64 x))
(- (+ y (* -1 (/ z (+ 1 x)))) (log (+ 1 x)))
(+.f64 (/.f64 z (-.f64 #s(literal -1 binary64) x)) (-.f64 y (log1p.f64 x)))
(- (+ y (* z (- (* 1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x))))) (log (+ 1 x)))
(fma.f64 z (fma.f64 z (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64)))) (/.f64 #s(literal -1 binary64) (+.f64 x #s(literal 1 binary64)))) (-.f64 y (log1p.f64 x)))
(- (+ y (* z (- (* z (+ (* -1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x))))) (log (+ 1 x)))
(fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 x #s(literal 1 binary64)) (.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 x #s(literal 1 binary64)))) (-.f64 y (log1p.f64 x)))
(- y (* -1 (log (/ 1 z))))
(-.f64 y (log.f64 z))
(- (+ y (* -1 (/ (+ 1 x) z))) (* -1 (log (/ 1 z))))
(+.f64 (/.f64 (-.f64 #s(literal -1 binary64) x) z) (-.f64 y (log.f64 z)))
(- (+ y (* 1/2 (/ (pow (+ 1 x) 2) (pow z 2)))) (+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64))) (.f64 z z)) y) (+.f64 (/.f64 x z) (+.f64 (/.f64 #s(literal 1 binary64) z) (log.f64 z))))
(- (+ y (* -1/3 (/ (pow (+ 1 x) 3) (pow z 3)))) (+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z)))))
(-.f64 (fma.f64 #s(literal -1/3 binary64) (/.f64 (.f64 (+.f64 x #s(literal 1 binary64)) (.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64)))) (.f64 z (.f64 z z))) (-.f64 y (log.f64 z))) (+.f64 (/.f64 x z) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64))) (.f64 z z)) (/.f64 #s(literal 1 binary64) z))))
(* -1 z)
(neg.f64 z)
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(neg.f64 (fma.f64 (neg.f64 z) (/.f64 (+.f64 y (-.f64 #s(literal -1 binary64) x)) z) z))
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(neg.f64 (fma.f64 (neg.f64 z) (/.f64 (+.f64 y (-.f64 #s(literal -1 binary64) x)) z) z))
(* -1 (* z (+ 1 (* -1 (/ (- y (+ 1 x)) z)))))
(neg.f64 (fma.f64 (neg.f64 z) (/.f64 (+.f64 y (-.f64 #s(literal -1 binary64) x)) z) z))
(- y (log (+ 1 z)))
(-.f64 y (log1p.f64 z))
(- (+ y (* -1 (/ x (+ 1 z)))) (log (+ 1 z)))
(+.f64 y (-.f64 (/.f64 x (-.f64 #s(literal -1 binary64) z)) (log1p.f64 z)))
(- (+ y (* x (- (* 1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z))))) (log (+ 1 z)))
(fma.f64 x (fma.f64 x (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (/.f64 #s(literal -1 binary64) (+.f64 z #s(literal 1 binary64)))) (-.f64 y (log1p.f64 z)))
(- (+ y (* x (- (* x (+ (* -1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z))))) (log (+ 1 z)))
(fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z #s(literal 1 binary64)))) (-.f64 y (log1p.f64 z)))
(- y (* -1 (log (/ 1 x))))
(-.f64 y (log.f64 x))
(- (+ y (* -1 (/ (+ 1 z) x))) (* -1 (log (/ 1 x))))
(+.f64 (/.f64 (-.f64 #s(literal -1 binary64) z) x) (-.f64 y (log.f64 x)))
(- (+ y (* 1/2 (/ (pow (+ 1 z) 2) (pow x 2)))) (+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x x)) (-.f64 y (+.f64 (log.f64 x) (+.f64 (/.f64 z x) (/.f64 #s(literal 1 binary64) x)))))
(- (+ y (* -1/3 (/ (pow (+ 1 z) 3) (pow x 3)))) (+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x)))))
(-.f64 (fma.f64 #s(literal -1/3 binary64) (.f64 (+.f64 z #s(literal 1 binary64)) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x (.f64 x x)))) y) (+.f64 (log.f64 x) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x x)) (+.f64 (/.f64 z x) (/.f64 #s(literal 1 binary64) x)))))
(* -1 x)
(neg.f64 x)
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(neg.f64 (fma.f64 x (/.f64 (-.f64 y (+.f64 z #s(literal 1 binary64))) (neg.f64 x)) x))
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(neg.f64 (fma.f64 x (/.f64 (-.f64 y (+.f64 z #s(literal 1 binary64))) (neg.f64 x)) x))
(* -1 (* x (+ 1 (* -1 (/ (- y (+ 1 z)) x)))))
(neg.f64 (fma.f64 x (/.f64 (-.f64 y (+.f64 z #s(literal 1 binary64))) (neg.f64 x)) x))
(- (+ y (* b (- a 1/2))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ x (- (+ a z) 1/2))) (* b (- a 1/2)))) (log (- (+ a z) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 x (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* 1/2 (/ x (pow (- (+ a z) 1/2) 2))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 x (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* x (- (* x (+ (* -1/3 (/ x (pow (- (+ a z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a z) 1/2) 2))))) (/ 1 (- (+ a z) 1/2)))))) (log (- (+ a z) 1/2)))
(-.f64 (fma.f64 x (fma.f64 x (fma.f64 #s(literal -1/3 binary64) (/.f64 x (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64))) (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 z (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a y) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow x 2) (pow (- (+ a y) 1/2) 2))))) (+ (log (- (+ a y) 1/2)) (/ 1 (* x (- (+ a y) 1/2)))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (-.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (+.f64 (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow x 2) (pow (- (+ a y) 1/2) 2)))))) (+ (log (- (+ a y) 1/2)) (+ (/ 1 (* x (- (+ a y) 1/2))) (* 1/3 (/ 1 (* (pow x 3) (pow (- (+ a y) 1/2) 3)))))))
(-.f64 (-.f64 (-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64)))) (.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))) (log.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (.f64 x (.f64 x x)) (.f64 (+.f64 y (+.f64 a #s(literal -1/2 binary64))) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))) (+.f64 y (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1 binary64) (*.f64 x (+.f64 y (+.f64 a #s(literal -1/2 binary64))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (* b (- a 1/2)) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (*.f64 b (+.f64 a #s(literal -1/2 binary64))) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ z (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ z (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))
(- (+ z (+ (* b (- a 1/2)) (/ 1/2 (* (pow y 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* y (- (+ a x) 1/2)))))
(+.f64 z (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y y) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))))
(- (+ z (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow y 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* y (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow y 3) (pow (- (+ a x) 1/2) 3)))))))
(+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 y y) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (-.f64 z (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 y (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 y (.f64 y y)) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ a z) (+ 1/2 (* t z)))
(+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1 (/ z (- (+ a x) 1/2))) (* b (- a 1/2)))) (log (- (+ a x) 1/2)))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* 1/2 (/ z (pow (- (+ a x) 1/2) 2))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (+ (* b (- a 1/2)) (* z (- (* z (+ (* -1/3 (/ z (pow (- (+ a x) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ a x) 1/2) 2))))) (/ 1 (- (+ a x) 1/2)))))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 z (fma.f64 z (fma.f64 #s(literal -1/3 binary64) (/.f64 z (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))) (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y)) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a x) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))
(- (+ y (* b (- a 1/2))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(-.f64 (-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))))) (/.f64 #s(literal 1 binary64) (*.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))
(- (+ y (+ (* b (- a 1/2)) (/ 1/2 (* (pow z 2) (pow (- (+ a x) 1/2) 2))))) (+ (log (- (+ a x) 1/2)) (/ 1 (* z (- (+ a x) 1/2)))))
(-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64)))))))
(- (+ y (+ (* b (- a 1/2)) (* 1/2 (/ 1 (* (pow z 2) (pow (- (+ a x) 1/2) 2)))))) (+ (log (- (+ a x) 1/2)) (+ (/ 1 (* z (- (+ a x) 1/2))) (* 1/3 (/ 1 (* (pow z 3) (pow (- (+ a x) 1/2) 3)))))))
(-.f64 (-.f64 (+.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 z z)))) (+.f64 (log.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 z (+.f64 x (+.f64 a #s(literal -1/2 binary64))))))) (/.f64 #s(literal 1/3 binary64) (.f64 (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (+.f64 x (+.f64 a #s(literal -1/2 binary64)))) (.f64 (+.f64 x (+.f64 a #s(literal -1/2 binary64))) (.f64 z (*.f64 z z))))))
(- (+ a y) 1/2)
(+.f64 y (+.f64 a #s(literal -1/2 binary64)))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 a (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 a (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ a (+ y (+ (/ x (* z (log -1))) (/ (* b (- a 1/2)) (* z (log -1)))))) 1/2)
(+.f64 a (+.f64 (fma.f64 b (/.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 z (log.f64 #s(literal -1 binary64)))) (/.f64 x (.f64 z (log.f64 #s(literal -1 binary64))))) (+.f64 y #s(literal -1/2 binary64))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ 1 t)))
(+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* b (- a 1/2))) (log (/ -1 t)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (/.f64 #s(literal -1 binary64) t)))
(- (+ y (* -1/2 b)) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 b #s(literal -1/2 binary64) y) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- b (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 z #s(literal -1/2 binary64))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* 1/2 (/ a (pow (- (+ x z) 1/2) 2)))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (+.f64 x (+.f64 z #s(literal -1/2 binary64))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(- (+ y (+ (* -1/2 b) (* a (- (+ b (* a (+ (* -1/3 (/ a (pow (- (+ x z) 1/2) 3))) (* 1/2 (/ 1 (pow (- (+ x z) 1/2) 2)))))) (/ 1 (- (+ x z) 1/2)))))) (log (- (+ x z) 1/2)))
(-.f64 (fma.f64 a (fma.f64 a (fma.f64 #s(literal -1/3 binary64) (/.f64 a (.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (/.f64 #s(literal 1/2 binary64) (*.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (+.f64 b (/.f64 #s(literal -1 binary64) (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))) (fma.f64 b #s(literal -1/2 binary64) y)) (log.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64)))))
(* a b)
(*.f64 b a)
(* a (- (+ b (+ (* -1/2 (/ b a)) (/ y a))) (* -1 (/ (log (/ 1 a)) a))))
(*.f64 a (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (-.f64 b (/.f64 (log.f64 a) a))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (/ 1/2 (pow a 2)) (/ y a)))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (+.f64 (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a))) (-.f64 b (/.f64 (log.f64 a) a))) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (.f64 a a)))))
(* a (- (+ b (+ (* -1/2 (/ b a)) (+ (* 1/2 (/ (pow (- (+ x z) 1/2) 2) (pow a 3))) (+ (/ 1/2 (pow a 2)) (/ y a))))) (+ (* -1 (/ (log (/ 1 a)) a)) (+ (/ x (pow a 2)) (/ z (pow a 2))))))
(.f64 a (-.f64 (+.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (/.f64 (+.f64 x (+.f64 z #s(literal -1/2 binary64))) (.f64 a (.f64 a a)))) (+.f64 (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 y a)) (/.f64 #s(literal 1/2 binary64) (.f64 a a)))) (-.f64 b (/.f64 (log.f64 a) a))) (+.f64 (/.f64 x (.f64 a a)) (/.f64 z (*.f64 a a)))))
(* a b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(* -1 (* a (+ (* -1 b) (* -1 (/ (- (+ x (+ y (+ z (* -1/2 b)))) (* z (log t))) a)))))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 b) (/.f64 (+.f64 x (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (fma.f64 b #s(literal -1/2 binary64) y))) a)))
(- y (log (- (+ a (+ x z)) 1/2)))
(-.f64 y (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(- (+ y (* b (- a 1/2))) (log (- (+ a (+ x z)) 1/2)))
(-.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) y) (log.f64 (+.f64 #s(literal -1/2 binary64) (+.f64 z (+.f64 x a)))))
(* 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 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(* b (- (+ a (+ (/ x b) (+ (/ y b) (/ z b)))) (+ 1/2 (/ (* z (log t)) b))))
(*.f64 b (+.f64 (+.f64 a (/.f64 x b)) (+.f64 (/.f64 y b) (-.f64 (/.f64 z b) (fma.f64 z (/.f64 (log.f64 t) b) #s(literal 1/2 binary64))))))
(- y (log (+ 1 (+ x z))))
(-.f64 y (log1p.f64 (+.f64 x z)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 x z)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 x z)))
(- (+ y (/ 1 b)) (log (+ 1 (+ x z))))
(-.f64 (+.f64 y (/.f64 #s(literal 1 binary64) b)) (log1p.f64 (+.f64 x z)))
(- (+ y z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
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 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(* -1 (* x (- (* -1 (/ (- (+ y z) (* z (log t))) x)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x)) (neg.f64 x))
(- (+ x z) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
y
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
(* y (- (+ 1 (+ (/ x y) (/ z y))) (/ (* z (log t)) y)))
(.f64 y (+.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) y))))
y
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(* -1 (* y (- (* -1 (/ (- (+ x z) (* z (log t))) y)) 1)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x) y)) (neg.f64 y))
(+ x y)
(+.f64 x y)
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(+ x (+ y (* z (- 1 (log t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(* z (- 1 (log t)))
(-.f64 z (*.f64 z (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 z (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 x y) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 x y) z)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ x y) z)) (+ 1 (* -1 (log t))))))
(*.f64 (-.f64 (+.f64 (log.f64 t) #s(literal -1 binary64)) (/.f64 (+.f64 x y) z)) (neg.f64 z))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (log t)))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* -1 (* z (log (/ 1 t)))))
(fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x y) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x y) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x y) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z))
(- (+ x (+ y z)) (* z (+ (log -1) (* -1 (log (/ -1 t))))))
(+.f64 (+.f64 x y) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z))
(+ z (* -1 (* z (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(+ z (* -1 (* z (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(+ z (* -1 (* z (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(+ z (* -1 (* z (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(+ z (* z (log (/ 1 t))))
(-.f64 z (*.f64 z (log.f64 t)))
(+ z (* z (log (/ 1 t))))
(-.f64 z (*.f64 z (log.f64 t)))
(+ z (* z (log (/ 1 t))))
(-.f64 z (*.f64 z (log.f64 t)))
(+ z (* z (log (/ 1 t))))
(-.f64 z (*.f64 z (log.f64 t)))
(+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z)
(+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z)
(+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z)
(+ z (* -1 (* z (+ (log -1) (* -1 (log (/ -1 t)))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) t))) (neg.f64 z) z)
(* z (+ 1 (* -1 (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(* z (+ 1 (* -1 (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(* z (+ 1 (* -1 (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(* z (+ 1 (* -1 (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(* z (+ 1 (* -1 (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(* z (+ 1 (* -1 (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(* z (+ 1 (* -1 (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(* z (+ 1 (* -1 (log t))))
(-.f64 z (*.f64 z (log.f64 t)))
(* -1 (* z (- (log t) 1)))
(neg.f64 (-.f64 (*.f64 z (log.f64 t)) z))
(* -1 (* z (- (log t) 1)))
(neg.f64 (-.f64 (*.f64 z (log.f64 t)) z))
(* -1 (* z (- (log t) 1)))
(neg.f64 (-.f64 (*.f64 z (log.f64 t)) z))
(* -1 (* z (- (log t) 1)))
(neg.f64 (-.f64 (*.f64 z (log.f64 t)) z))
(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)))
(log (+ 1 x))
(log1p.f64 x)
(+ (log (+ 1 x)) (/ z (+ 1 x)))
(+.f64 (log1p.f64 x) (/.f64 z (+.f64 x #s(literal 1 binary64))))
(+ (log (+ 1 x)) (* z (+ (* -1/2 (/ z (pow (+ 1 x) 2))) (/ 1 (+ 1 x)))))
(fma.f64 z (fma.f64 #s(literal -1/2 binary64) (/.f64 z (*.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 x #s(literal 1 binary64)))) (log1p.f64 x))
(+ (log (+ 1 x)) (* z (+ (* z (- (* 1/3 (/ z (pow (+ 1 x) 3))) (* 1/2 (/ 1 (pow (+ 1 x) 2))))) (/ 1 (+ 1 x)))))
(fma.f64 z (fma.f64 z (fma.f64 #s(literal 1/3 binary64) (/.f64 z (.f64 (+.f64 x #s(literal 1 binary64)) (.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64))))) (/.f64 #s(literal -1/2 binary64) (*.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64))))) (/.f64 #s(literal 1 binary64) (+.f64 x #s(literal 1 binary64)))) (log1p.f64 x))
(* -1 (log (/ 1 z)))
(log.f64 z)
(+ (* -1 (log (/ 1 z))) (+ (/ 1 z) (/ x z)))
(+.f64 (/.f64 x z) (+.f64 (/.f64 #s(literal 1 binary64) z) (log.f64 z)))
(+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (/ 1 z) (/ x z))))
(+.f64 (log.f64 z) (+.f64 (/.f64 x z) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64))) (.f64 z z)) (/.f64 #s(literal 1 binary64) z))))
(+ (* -1 (log (/ 1 z))) (+ (* -1/2 (/ (pow (+ 1 x) 2) (pow z 2))) (+ (* 1/3 (/ (pow (+ 1 x) 3) (pow z 3))) (+ (/ 1 z) (/ x z)))))
(+.f64 (+.f64 (/.f64 x z) (fma.f64 #s(literal 1/3 binary64) (/.f64 (.f64 (+.f64 x #s(literal 1 binary64)) (.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64)))) (.f64 z (.f64 z z))) (/.f64 #s(literal 1 binary64) z))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 x #s(literal 1 binary64)) (+.f64 x #s(literal 1 binary64))) (.f64 z z)) (log.f64 z)))
z
(* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))
(neg.f64 (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))
(neg.f64 (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ 1 x) z)) 1)))
(neg.f64 (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z)))
(log (+ 1 z))
(log1p.f64 z)
(+ (log (+ 1 z)) (/ x (+ 1 z)))
(+.f64 (log1p.f64 z) (/.f64 x (+.f64 z #s(literal 1 binary64))))
(+ (log (+ 1 z)) (* x (+ (* -1/2 (/ x (pow (+ 1 z) 2))) (/ 1 (+ 1 z)))))
(fma.f64 x (fma.f64 #s(literal -1/2 binary64) (/.f64 x (*.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 z #s(literal 1 binary64)))) (log1p.f64 z))
(+ (log (+ 1 z)) (* x (+ (* x (- (* 1/3 (/ x (pow (+ 1 z) 3))) (* 1/2 (/ 1 (pow (+ 1 z) 2))))) (/ 1 (+ 1 z)))))
(fma.f64 x (fma.f64 x (fma.f64 #s(literal 1/3 binary64) (/.f64 x (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))))) (/.f64 #s(literal -1/2 binary64) (*.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))))) (/.f64 #s(literal 1 binary64) (+.f64 z #s(literal 1 binary64)))) (log1p.f64 z))
(* -1 (log (/ 1 x)))
(log.f64 x)
(+ (* -1 (log (/ 1 x))) (+ (/ 1 x) (/ z x)))
(+.f64 (log.f64 x) (+.f64 (/.f64 z x) (/.f64 #s(literal 1 binary64) x)))
(+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (/ 1 x) (/ z x))))
(+.f64 (log.f64 x) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x x)) (+.f64 (/.f64 z x) (/.f64 #s(literal 1 binary64) x))))
(+ (* -1 (log (/ 1 x))) (+ (* -1/2 (/ (pow (+ 1 z) 2) (pow x 2))) (+ (* 1/3 (/ (pow (+ 1 z) 3) (pow x 3))) (+ (/ 1 x) (/ z x)))))
(+.f64 (log.f64 x) (fma.f64 #s(literal 1/3 binary64) (.f64 (+.f64 z #s(literal 1 binary64)) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x (.f64 x x)))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (.f64 x x)) (+.f64 (/.f64 z x) (/.f64 #s(literal 1 binary64) x)))))
x
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(neg.f64 (fma.f64 x (/.f64 (-.f64 #s(literal -1 binary64) z) x) (neg.f64 x)))
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(neg.f64 (fma.f64 x (/.f64 (-.f64 #s(literal -1 binary64) z) x) (neg.f64 x)))
(* -1 (* x (- (* -1 (/ (+ 1 z) x)) 1)))
(neg.f64 (fma.f64 x (/.f64 (-.f64 #s(literal -1 binary64) z) x) (neg.f64 x)))
-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 b)
(*.f64 b a)
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(.f64 (neg.f64 a) (-.f64 (/.f64 (.f64 b #s(literal 1/2 binary64)) a) b))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(.f64 (neg.f64 a) (-.f64 (/.f64 (.f64 b #s(literal 1/2 binary64)) a) b))
(* -1 (* a (+ (* -1 b) (* 1/2 (/ b a)))))
(.f64 (neg.f64 a) (-.f64 (/.f64 (.f64 b #s(literal 1/2 binary64)) a) b))
(- 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 1/2)
(+.f64 a #s(literal -1/2 binary64))
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
(/ 1 b)
(/.f64 #s(literal 1 binary64) b)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)
1
#s(literal 1 binary64)

rewrite442.0ms (2.8%)

Memory

-3.7MiB live, 588.0MiB allocated

Rules

5 818×	`lower-*.f32`
5 814×	`lower-*.f64`
3 326×	`lower-/.f32`
3 324×	`lower-/.f64`
2 478×	`lower-fma.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	48	293
0	67	293
1	320	289
2	2723	289
0	8503	276

Stop Event

1×	iter limit
1×	node limit
1×	iter limit

Counts

21 → 225

Calls

Call 1

Inputs
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x))
(neg.f64 x)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x))
(+.f64 y x)
#s(approx (* (- a 1/2) b) #s(literal 1 binary64))
(*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))
(neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
#s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z))
(fma.f64 (log.f64 t) (neg.f64 z) z)
(log.f64 t)
#s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))
#s(approx (* (- a 1/2) b) (*.f64 b a))

Outputs
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
(+.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 b a))
(+.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))
(+.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))
(+.f64 (.f64 b #s(literal -1/2 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (*.f64 b a)))
(+.f64 (fma.f64 b a #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 b #s(literal -1/2 binary64)))
(-.f64 (/.f64 (.f64 b (.f64 a (.f64 b a))) (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (/.f64 (.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(fma.f64 b #s(literal -1/2 binary64) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 b a)))
(fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(fma.f64 a b (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(fma.f64 #s(literal -1/2 binary64) b (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 b a)))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(fma.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b #s(literal -1/2 binary64))) (.f64 #s(literal 1/4 binary64) (.f64 b b)))) (.f64 b a))
(fma.f64 (-.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 b #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))) (*.f64 b a))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (fma.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (.f64 (.f64 b a) (.f64 b (.f64 a (*.f64 b a)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))) (.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))))
(/.f64 (fma.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (.f64 (.f64 b a) (.f64 b (.f64 a (.f64 b a))))) (fma.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))))
(/.f64 (fma.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (.f64 (.f64 b a) (.f64 b (.f64 a (.f64 b a))))) (fma.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 (.f64 b (.f64 a (.f64 b a))) (.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (*.f64 b a)))))
(/.f64 (.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))) (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))
(/.f64 (neg.f64 (fma.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (.f64 (.f64 b a) (.f64 b (.f64 a (.f64 b a)))))) (neg.f64 (fma.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 b a)) (.f64 b (.f64 a (.f64 b a))))))
(/.f64 (neg.f64 (.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))) (neg.f64 (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))))
(/.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (-.f64 (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
(/.f64 (-.f64 (.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (.f64 b (.f64 a (.f64 b a)))) (-.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (*.f64 b a)))
(/.f64 (-.f64 (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))
(/.f64 (-.f64 (.f64 (.f64 b (.f64 a (.f64 b a))) (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))) (.f64 (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))))) (.f64 (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))))
(pow.f64 (/.f64 (fma.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 b a)) (.f64 b (.f64 a (.f64 b a)))) (fma.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (.f64 (.f64 b a) (.f64 b (.f64 a (*.f64 b a)))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))) (.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))) #s(literal -1 binary64))
(.f64 (fma.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (.f64 (.f64 b a) (.f64 b (.f64 a (.f64 b a))))) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 b a)) (.f64 b (.f64 a (.f64 b a))))))
(.f64 (.f64 (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 b a) (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 b #s(literal -1/2 binary64)))
(+.f64 (.f64 b #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))
(-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (-.f64 (.f64 b #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))) (/.f64 (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 (.f64 b #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))
(fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(fma.f64 #s(literal -1/2 binary64) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b #s(literal -1/2 binary64))) (.f64 #s(literal 1/4 binary64) (.f64 b b))) (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (.f64 b #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
(/.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b #s(literal -1/2 binary64))) (.f64 #s(literal 1/4 binary64) (*.f64 b b))))
(/.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (-.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (*.f64 b #s(literal -1/2 binary64))))))
(/.f64 (-.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (-.f64 (.f64 b #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))))
(/.f64 (neg.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64)))) (neg.f64 (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b #s(literal -1/2 binary64))) (.f64 #s(literal 1/4 binary64) (*.f64 b b)))))
(/.f64 (neg.f64 (-.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (neg.f64 (-.f64 (.f64 b #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))
(/.f64 (-.f64 (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(literal 1/4 binary64) (.f64 b b))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (*.f64 b #s(literal -1/2 binary64))))
(/.f64 (-.f64 (.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (-.f64 (.f64 b #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (.f64 (-.f64 (.f64 b #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (.f64 (-.f64 (.f64 b #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 (.f64 b #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))
(pow.f64 (/.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b #s(literal -1/2 binary64))) (.f64 #s(literal 1/4 binary64) (.f64 b b))) (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (.f64 b (*.f64 b b)) #s(literal -1/8 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 (.f64 b #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (-.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) #s(literal -1 binary64))
(.f64 (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 (.f64 b (.f64 b b)) #s(literal -1/8 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 b #s(literal -1/2 binary64))) (.f64 #s(literal 1/4 binary64) (*.f64 b b)))))
(.f64 (-.f64 (.f64 #s(literal 1/4 binary64) (.f64 b b)) (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 b #s(literal -1/2 binary64)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
(+.f64 y x)
(-.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)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x x (.f64 y (-.f64 y x))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 x y) (*.f64 (+.f64 x y) (-.f64 x y))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 y x) (*.f64 (+.f64 x y) (-.f64 y x))))
(/.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 x x (.f64 y (-.f64 y x))))
(/.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 x (-.f64 x y) (.f64 y y)))
(/.f64 (*.f64 (+.f64 x y) (-.f64 x y)) (-.f64 x y))
(/.f64 (*.f64 (+.f64 x y) (-.f64 y x)) (-.f64 y x))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 x x (.f64 y (-.f64 y x)))))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 x (-.f64 x y) (.f64 y y))))
(/.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y))) (neg.f64 (-.f64 x y)))
(/.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 y x))) (neg.f64 (-.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 (-.f64 (.f64 (.f64 y y) (-.f64 y x)) (.f64 (-.f64 y x) (.f64 x x))) (*.f64 (-.f64 y x) (-.f64 y x)))
(pow.f64 (/.f64 (fma.f64 x x (.f64 y (-.f64 y x))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 x y) (*.f64 (+.f64 x y) (-.f64 x y))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 y x) (*.f64 (+.f64 x y) (-.f64 y x))) #s(literal -1 binary64))
(.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (*.f64 y (-.f64 y x)))))
(.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x (-.f64 x y) (*.f64 y y))))
(.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)))
(.f64 (.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x))
(+.f64 #s(literal 0 binary64) (neg.f64 x))
(-.f64 #s(literal 0 binary64) x)
(neg.f64 x)
(/.f64 (-.f64 #s(literal 0 binary64) (.f64 x (.f64 x x))) (+.f64 #s(literal 0 binary64) (fma.f64 x x (*.f64 #s(literal 0 binary64) x))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 x x)) (+.f64 #s(literal 0 binary64) x))
(*.f64 x #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) x)
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
(+.f64 #s(approx (* (- a 1/2) b) #s(literal 1 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(-.f64 (/.f64 (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))) (/.f64 (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) (-.f64 #s(approx (* (- a 1/2) b) #s(literal 1 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))) (.f64 (+.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))))))
(/.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))))) (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) (-.f64 #s(approx (* (- a 1/2) b) #s(literal 1 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
(/.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))))) (fma.f64 #s(approx (* (- a 1/2) b) #s(literal 1 binary64)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)) (-.f64 (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))))))
(/.f64 (.f64 (+.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))))
(/.f64 (neg.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))))) (neg.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) (-.f64 #s(approx (* (- a 1/2) b) #s(literal 1 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))))))
(/.f64 (neg.f64 (.f64 (+.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))))) (neg.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))))
(/.f64 (-.f64 (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) (-.f64 #s(approx (* (- a 1/2) b) #s(literal 1 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(/.f64 (-.f64 (.f64 (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))) (.f64 (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))))) (.f64 (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))))
(pow.f64 (/.f64 (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) (-.f64 #s(approx (* (- a 1/2) b) #s(literal 1 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))) (.f64 (+.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))))) #s(literal -1 binary64))
(.f64 (fma.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx ( (- a 1/2) b) #s(literal 1 binary64)) (-.f64 #s(approx (* (- a 1/2) b) #s(literal 1 binary64)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))))))
(.f64 (.f64 (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64))) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))))
#s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))
(+.f64 x y)
(+.f64 y x)
(-.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)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x x (.f64 y (-.f64 y x))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 x y) (*.f64 (+.f64 x y) (-.f64 x y))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 y x) (*.f64 (+.f64 x y) (-.f64 y x))))
(/.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 x x (.f64 y (-.f64 y x))))
(/.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (fma.f64 x (-.f64 x y) (.f64 y y)))
(/.f64 (*.f64 (+.f64 x y) (-.f64 x y)) (-.f64 x y))
(/.f64 (*.f64 (+.f64 x y) (-.f64 y x)) (-.f64 y x))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 x x (.f64 y (-.f64 y x)))))
(/.f64 (neg.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) (neg.f64 (fma.f64 x (-.f64 x y) (.f64 y y))))
(/.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y))) (neg.f64 (-.f64 x y)))
(/.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 y x))) (neg.f64 (-.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 (-.f64 (.f64 (.f64 y y) (-.f64 y x)) (.f64 (-.f64 y x) (.f64 x x))) (*.f64 (-.f64 y x) (-.f64 y x)))
(pow.f64 (/.f64 (fma.f64 x x (.f64 y (-.f64 y x))) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 x y) (*.f64 (+.f64 x y) (-.f64 x y))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 y x) (*.f64 (+.f64 x y) (-.f64 y x))) #s(literal -1 binary64))
(.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (*.f64 y (-.f64 y x)))))
(.f64 (fma.f64 x (.f64 x x) (.f64 y (.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 x (-.f64 x y) (*.f64 y y))))
(.f64 (.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)))
(.f64 (.f64 (+.f64 x y) (-.f64 y x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)))
#s(approx (* (- a 1/2) b) #s(literal 1 binary64))
(+.f64 (neg.f64 x) (*.f64 x (/.f64 (+.f64 #s(literal -1 binary64) (neg.f64 z)) x)))
(+.f64 (neg.f64 x) (*.f64 (/.f64 (+.f64 #s(literal -1 binary64) (neg.f64 z)) x) x))
(fma.f64 x #s(literal -1 binary64) (*.f64 x (/.f64 (+.f64 #s(literal -1 binary64) (neg.f64 z)) x)))
(fma.f64 x #s(literal -1 binary64) (*.f64 (/.f64 (+.f64 #s(literal -1 binary64) (neg.f64 z)) x) x))
(fma.f64 #s(literal -1 binary64) x (*.f64 x (/.f64 (+.f64 #s(literal -1 binary64) (neg.f64 z)) x)))
(fma.f64 #s(literal -1 binary64) x (*.f64 (/.f64 (+.f64 #s(literal -1 binary64) (neg.f64 z)) x) x))
(/.f64 (.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (.f64 x (*.f64 x x))))) (fma.f64 (/.f64 (+.f64 z #s(literal 1 binary64)) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) #s(literal 1 binary64)))
(/.f64 (.f64 x (-.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (*.f64 x x)))) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))
(/.f64 (.f64 (-.f64 #s(literal -1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (.f64 x (*.f64 x x)))) x) (fma.f64 (/.f64 (+.f64 z #s(literal 1 binary64)) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) #s(literal 1 binary64)))
(/.f64 (.f64 (-.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (*.f64 x x))) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))
(*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) x)
(+.f64 #s(literal 0 binary64) (*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))
(+.f64 (.f64 (neg.f64 x) #s(literal -1 binary64)) (.f64 (neg.f64 x) (/.f64 (+.f64 #s(literal -1 binary64) (neg.f64 z)) x)))
(+.f64 (.f64 #s(literal -1 binary64) (neg.f64 x)) (.f64 (/.f64 (+.f64 #s(literal -1 binary64) (neg.f64 z)) x) (neg.f64 x)))
(-.f64 #s(literal 0 binary64) (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))
(fma.f64 (neg.f64 x) #s(literal -1 binary64) (*.f64 (neg.f64 x) (/.f64 (+.f64 #s(literal -1 binary64) (neg.f64 z)) x)))
(fma.f64 #s(literal -1 binary64) (neg.f64 x) (*.f64 (/.f64 (+.f64 #s(literal -1 binary64) (neg.f64 z)) x) (neg.f64 x)))
(neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))
(/.f64 (-.f64 #s(literal 0 binary64) (.f64 (.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))) (.f64 (.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))) (.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))) (+.f64 #s(literal 0 binary64) (fma.f64 (.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))) (.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))) (.f64 #s(literal 0 binary64) (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (.f64 (.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))) (.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (+.f64 #s(literal 0 binary64) (.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))
(/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (.f64 x (*.f64 x x))))) (fma.f64 (/.f64 (+.f64 z #s(literal 1 binary64)) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) #s(literal 1 binary64)))
(/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (*.f64 x x)))) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))
(*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))
(*.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))
(.f64 #s(literal -1 binary64) (.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))
(*.f64 (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) (neg.f64 x))
(.f64 (.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))) #s(literal -1 binary64))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) x)
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(+.f64 y (neg.f64 #s(approx (log (+ 1 (+ z x))) (*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(+.f64 (neg.f64 #s(approx (log (+ 1 (+ z x))) (*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) y)
(-.f64 y #s(approx (log (+ 1 (+ z x))) (*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))
(-.f64 (/.f64 (.f64 y (.f64 y y)) (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y))) (/.f64 (.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))) (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (*.f64 y y))))
(-.f64 (/.f64 (.f64 y y) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))) (/.f64 (.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(fma.f64 #s(literal -1 binary64) #s(approx (log (+ 1 (+ z x))) (*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) y)
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y)) (.f64 (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))))
(/.f64 (.f64 (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))) (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y)))
(/.f64 (.f64 (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))) (fma.f64 y y (-.f64 (.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y (neg.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))))
(/.f64 (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(/.f64 (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))) (-.f64 y (neg.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(/.f64 (neg.f64 (.f64 (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))) (neg.f64 (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y))))
(/.f64 (neg.f64 (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))) (neg.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(/.f64 (-.f64 (.f64 (.f64 y (.f64 y y)) (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y))) (.f64 (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y)) (.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))) (.f64 (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y)) (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y))))
(/.f64 (-.f64 (.f64 (.f64 y y) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(pow.f64 (/.f64 (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y)) (.f64 (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))) #s(literal -1 binary64))
(.f64 (.f64 (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 y y)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))) (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (*.f64 y y))))
(.f64 (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))) (/.f64 #s(literal 1 binary64) (+.f64 y #s(approx (log (+ 1 (+ z x))) (*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(+.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)))
(-.f64 (/.f64 (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (.f64 b a)))) (/.f64 (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z))) (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (.f64 b a))) (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (*.f64 b a))))))
(/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 3 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z))) (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64))))
(/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 3 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)) (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a))))))
(/.f64 (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))) (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a))))
(/.f64 (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z))) (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))) (neg.f64 (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(/.f64 (-.f64 (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64))) (-.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z))))
(/.f64 (-.f64 (.f64 (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64)) (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (.f64 b a)))) (.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (.f64 b a))) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))))) (.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (.f64 b a))) (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(pow.f64 (/.f64 (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z))) (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64))) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (.f64 b a))) (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (*.f64 b a))))) #s(literal -1 binary64))
(.f64 (fma.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) (.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a))) (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) (-.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z))) (pow.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64)))))
(.f64 (-.f64 (pow.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) (.f64 b a)) #s(approx ( (- a 1/2) b) (.f64 b a)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
#s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z))
(+.f64 z (*.f64 (log.f64 t) (neg.f64 z)))
(+.f64 (*.f64 (log.f64 t) (neg.f64 z)) z)
(-.f64 z (*.f64 z (log.f64 t)))
(-.f64 (/.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (neg.f64 z))) (/.f64 (.f64 z z) (fma.f64 (log.f64 t) (neg.f64 z) (neg.f64 z))))
(fma.f64 z #s(literal 1 binary64) (*.f64 (log.f64 t) (neg.f64 z)))
(fma.f64 z (neg.f64 (log.f64 t)) z)
(fma.f64 #s(literal 1 binary64) z (*.f64 (log.f64 t) (neg.f64 z)))
(fma.f64 #s(literal -1 binary64) (*.f64 z (log.f64 t)) z)
(fma.f64 (log.f64 t) (neg.f64 z) z)
(fma.f64 (neg.f64 z) (log.f64 t) z)
(fma.f64 (neg.f64 (log.f64 t)) z z)
(fma.f64 (*.f64 (log.f64 t) #s(literal -1 binary64)) z z)
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 z (-.f64 z (.f64 (log.f64 t) (neg.f64 z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (fma.f64 z (.f64 z z) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 t) (neg.f64 z) (neg.f64 z)) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z z))))
(/.f64 (fma.f64 z (.f64 z z) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (fma.f64 z (-.f64 z (.f64 (log.f64 t) (neg.f64 z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))))
(/.f64 (fma.f64 z (.f64 z z) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 (log.f64 t) (*.f64 (neg.f64 z) z)))))
(/.f64 (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z z)) (fma.f64 (log.f64 t) (neg.f64 z) (neg.f64 z)))
(/.f64 (neg.f64 (fma.f64 z (.f64 z z) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 z (-.f64 z (.f64 (log.f64 t) (neg.f64 z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z z))) (neg.f64 (fma.f64 (log.f64 t) (neg.f64 z) (neg.f64 z))))
(/.f64 (-.f64 (.f64 z (.f64 z z)) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (fma.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 z z) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (-.f64 z (*.f64 (log.f64 t) (neg.f64 z))))
(/.f64 (-.f64 (.f64 z z) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (+.f64 z (*.f64 z (log.f64 t))))
(/.f64 (-.f64 (.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (fma.f64 (log.f64 t) (neg.f64 z) (neg.f64 z))) (.f64 (fma.f64 (log.f64 t) (neg.f64 z) (neg.f64 z)) (.f64 z z))) (*.f64 (fma.f64 (log.f64 t) (neg.f64 z) (neg.f64 z)) (fma.f64 (log.f64 t) (neg.f64 z) (neg.f64 z))))
(pow.f64 (/.f64 (fma.f64 z (-.f64 z (.f64 (log.f64 t) (neg.f64 z))) (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64))) (fma.f64 z (.f64 z z) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (log.f64 t) (neg.f64 z) (neg.f64 z)) (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (.f64 z z))) #s(literal -1 binary64))
(.f64 (fma.f64 z (.f64 z z) (pow.f64 (.f64 z (log.f64 t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (.f64 (log.f64 t) (neg.f64 z))) (pow.f64 (*.f64 z (log.f64 t)) #s(literal 2 binary64)))))
(.f64 (-.f64 (pow.f64 (.f64 z (log.f64 t)) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 t) (neg.f64 z) (neg.f64 z))))
(log.f64 t)
#s(approx (log (+ 1 (+ z x))) (*.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))
#s(approx (* (- a 1/2) b) (*.f64 b a))

eval179.0ms (1.1%)

Memory: 16.7MiB live, 294.7MiB allocated
Compiler: Compiled 20 792 to 1 187 computations (94.3% saved)

prune213.0ms (1.4%)

Memory

5.8MiB live, 320.0MiB allocated

Pruning

39 alts after pruning (35 fresh and 4 done)

	Pruned	Kept	Total
New	1 021	13	1 034
Fresh	3	22	25
Picked	3	2	5
Done	0	2	2
Total	1 027	39	1 066

Accuracy

100.0%

Counts

1 066 → 39

Alt Table

Click to see full alt table

Status	Accuracy	Program
	62.5%	(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)))
	70.1%	(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (fma.f64 x (/.f64 y x) x))))
	43.6%	(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
	51.8%	(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
	49.7%	(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (-.f64 z (*.f64 z (log.f64 t)))))
	39.6%	(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (*.f64 b #s(literal -1/2 binary64))))
	23.5%	(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))
	62.4%	(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (+ (* (log t) (neg z)) (+ x (+ y z))) (fma.f64 (log.f64 t) (neg.f64 z) z)))))
	4.1%	(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))))
	39.3%	(+.f64 (-.f64 #s(approx (+ (+ x y) z) (+.f64 z x)) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
✓	70.0%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
	49.9%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 x (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x) x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
	63.2%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
✓	36.0%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
	36.3%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
	43.9%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (.f64 y (-.f64 (+.f64 (/.f64 x y) (+.f64 #s(literal 1 binary64) (/.f64 z y))) (/.f64 (.f64 z (log.f64 t)) y)))) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
	48.0%	(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (.f64 x (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) x))))) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
	40.7%	#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
	28.7%	#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64))))
	19.7%	#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
	39.6%	#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
	24.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))
	61.4%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x)))
	71.9%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 a (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (+.f64 (+.f64 b (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 x a))) (+.f64 (/.f64 y a) (/.f64 z a))))))
	12.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))))
	17.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (*.f64 x x)))) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
	11.4%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (.f64 x (*.f64 x x))))) (fma.f64 (/.f64 (+.f64 z #s(literal 1 binary64)) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) #s(literal 1 binary64))))))
	31.1%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))))))
	23.0%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
	23.0%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))))))
	22.4%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
	23.6%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
	6.2%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64)))))
	21.8%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
✓	27.2%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
	3.9%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
✓	2.3%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
	3.1%	#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
	24.8%	#s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (*.f64 z (log.f64 t))))

Compiler

Compiled 1 796 to 676 computations (62.4% saved)

regimes484.0ms (3.1%)

Memory

-3.4MiB live, 842.5MiB allocated

Counts

72 → 1

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (*.f64 b #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (/.f64 #s(literal 1 binary64) b)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (fma.f64 x (/.f64 y x) x))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ y x) (fma.f64 x (/.f64 y x) x))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (*.f64 x x)))) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (.f64 x (*.f64 x x))))) (fma.f64 (/.f64 (+.f64 z #s(literal 1 binary64)) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) #s(literal 1 binary64))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
#s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (*.f64 z (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))
(.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x)))
(+.f64 (-.f64 #s(approx (+ (+ x y) z) (+.f64 z x)) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (-.f64 z (*.f64 z (log.f64 t)))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (-.f64 z (.f64 z (log.f64 t)))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) (*.f64 b a)))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (fma.f64 b a (.f64 b #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 x (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x) x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (+ (* (log t) (neg z)) (+ x (+ y z))) (fma.f64 (log.f64 t) (neg.f64 z) z)))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (.f64 x (neg.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y) x))))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 a #s(literal -1/2 binary64)) b (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (.f64 x (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) x))))) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (.f64 x (+.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 z (log.f64 t)) x))))) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (.f64 y (-.f64 (+.f64 (/.f64 x y) (+.f64 #s(literal 1 binary64) (/.f64 z y))) (/.f64 (.f64 z (log.f64 t)) y)))) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 x (-.f64 (+.f64 (/.f64 y x) (/.f64 z x)) (/.f64 (.f64 z (log.f64 t)) x)) x)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 y (-.f64 (+.f64 (/.f64 x y) (/.f64 z y)) (/.f64 (.f64 z (log.f64 t)) y)) y)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 a (fma.f64 z (neg.f64 (/.f64 (log.f64 t) a)) (+.f64 (+.f64 b (fma.f64 b (/.f64 #s(literal -1/2 binary64) a) (/.f64 x a))) (+.f64 (/.f64 y a) (/.f64 z a))))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 y (+.f64 x z))) #s(literal 2 binary64)) (.f64 #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))) (-.f64 (+.f64 y (+.f64 x z)) (fma.f64 z (log.f64 t) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))))
(+.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))) (fma.f64 z (log.f64 t) (+.f64 x (+.f64 y z)))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 t) (neg.f64 z) (+.f64 x (+.f64 y z))) #s(literal 2 binary64)) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 (+.f64 a #s(literal -1/2 binary64)) b)))) (-.f64 (+.f64 x (+.f64 y z)) (fma.f64 z (log.f64 t) (.f64 (+.f64 a #s(literal -1/2 binary64)) b))))

Outputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (fma.f64 b a (.f64 b #s(literal -1/2 binary64))))

Calls

12 calls:

80.0ms	(log.f64 t)
67.0ms	(+.f64 x y)
44.0ms	(-.f64 a #s(literal 1/2 binary64))
44.0ms	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
42.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))

Results

Accuracy	Segments	Branch
99.9%	1	`x`
99.9%	1	`y`
99.9%	1	`z`
99.9%	1	`t`
99.9%	1	`a`
99.9%	1	`b`
99.9%	1	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
99.9%	1	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
99.9%	1	`(+.f64 x y)`
99.9%	1	`(log.f64 t)`
99.9%	1	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
99.9%	1	`(-.f64 a #s(literal 1/2 binary64))`

Compiler

Compiled 117 to 93 computations (20.5% saved)

regimes262.0ms (1.7%)

Memory

-26.9MiB live, 503.0MiB allocated

Counts

58 → 1

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (*.f64 b #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (/.f64 #s(literal 1 binary64) b)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (fma.f64 x (/.f64 y x) x))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ y x) (fma.f64 x (/.f64 y x) x))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (*.f64 x x)))) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (.f64 x (*.f64 x x))))) (fma.f64 (/.f64 (+.f64 z #s(literal 1 binary64)) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) #s(literal 1 binary64))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
#s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (*.f64 z (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))
(.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x)))
(+.f64 (-.f64 #s(approx (+ (+ x y) z) (+.f64 z x)) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (-.f64 z (*.f64 z (log.f64 t)))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (-.f64 z (.f64 z (log.f64 t)))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) (*.f64 b a)))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.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:

56.0ms	y
20.0ms	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
19.0ms	a
19.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
18.0ms	(-.f64 a #s(literal 1/2 binary64))

Results

Accuracy	Segments	Branch
99.9%	1	`x`
99.9%	1	`y`
99.9%	1	`z`
99.9%	1	`t`
99.9%	1	`a`
99.9%	1	`b`
99.9%	1	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
99.9%	1	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
99.9%	1	`(+.f64 x y)`
99.9%	1	`(log.f64 t)`
99.9%	1	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
99.9%	1	`(-.f64 a #s(literal 1/2 binary64))`

Compiler

Compiled 117 to 93 computations (20.5% saved)

regimes243.0ms (1.6%)

Memory

9.5MiB live, 327.3MiB allocated

Counts

57 → 2

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (*.f64 b #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (/.f64 #s(literal 1 binary64) b)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (fma.f64 x (/.f64 y x) x))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ y x) (fma.f64 x (/.f64 y x) x))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (*.f64 x x)))) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (.f64 x (*.f64 x x))))) (fma.f64 (/.f64 (+.f64 z #s(literal 1 binary64)) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) #s(literal 1 binary64))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
#s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (*.f64 z (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))
(.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x)))
(+.f64 (-.f64 #s(approx (+ (+ x y) z) (+.f64 z x)) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (-.f64 z (*.f64 z (log.f64 t)))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (-.f64 z (.f64 z (log.f64 t)))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) (*.f64 b a)))

Outputs

(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))

Calls

12 calls:

41.0ms	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
30.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
18.0ms	a
18.0ms	x
18.0ms	z

Results

Accuracy	Segments	Branch
96.0%	2	`x`
97.4%	2	`y`
97.3%	3	`z`
88.7%	2	`t`
90.8%	3	`a`
95.8%	3	`b`
98.9%	2	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
99.3%	2	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
99.6%	2	`(+.f64 x y)`
88.7%	2	`(log.f64 t)`
94.7%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
86.4%	1	`(-.f64 a #s(literal 1/2 binary64))`

Compiler

Compiled 117 to 93 computations (20.5% saved)

regimes137.0ms (0.9%)

Memory

25.8MiB live, 222.4MiB allocated

Counts

54 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (*.f64 b #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (/.f64 #s(literal 1 binary64) b)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (fma.f64 x (/.f64 y x) x))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ y x) (fma.f64 x (/.f64 y x) x))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (*.f64 x x)))) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (.f64 x (*.f64 x x))))) (fma.f64 (/.f64 (+.f64 z #s(literal 1 binary64)) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) #s(literal 1 binary64))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
#s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (*.f64 z (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))
(.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x)))
(+.f64 (-.f64 #s(approx (+ (+ x y) z) (+.f64 z x)) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (-.f64 z (*.f64 z (log.f64 t)))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (-.f64 z (.f64 z (log.f64 t)))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Outputs

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))

(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))

Calls

7 calls:

35.0ms	b
18.0ms	x
18.0ms	(+.f64 x y)
17.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
17.0ms	y

Results

Accuracy	Segments	Branch
90.1%	3	`b`
95.7%	3	`z`
92.9%	2	`x`
87.2%	2	`y`
88.4%	3	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
89.3%	2	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
93.3%	2	`(+.f64 x y)`

Compiler

Compiled 75 to 57 computations (24% saved)

regimes76.0ms (0.5%)

Memory

6.2MiB live, 123.7MiB allocated

Counts

52 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (*.f64 b #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (/.f64 #s(literal 1 binary64) b)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (fma.f64 x (/.f64 y x) x))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ y x) (fma.f64 x (/.f64 y x) x))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (*.f64 x x)))) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (.f64 x (*.f64 x x))))) (fma.f64 (/.f64 (+.f64 z #s(literal 1 binary64)) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) #s(literal 1 binary64))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
#s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (*.f64 z (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))
(.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x)))
(+.f64 (-.f64 #s(approx (+ (+ x y) z) (+.f64 z x)) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (-.f64 z (*.f64 z (log.f64 t)))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)))

Outputs

(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))

(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))

(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))

Calls

4 calls:

26.0ms	z
17.0ms	x
15.0ms	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
14.0ms	(+.f64 x y)

Results

Accuracy	Segments	Branch
83.0%	2	`x`
91.9%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
89.4%	3	`(+.f64 x y)`
92.6%	3	`z`

Compiler

Compiled 34 to 28 computations (17.6% saved)

regimes84.0ms (0.5%)

Memory

-22.7MiB live, 52.3MiB allocated

Counts

49 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (*.f64 b #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (/.f64 #s(literal 1 binary64) b)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (fma.f64 x (/.f64 y x) x))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ y x) (fma.f64 x (/.f64 y x) x))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (*.f64 x x)))) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (.f64 x (*.f64 x x))))) (fma.f64 (/.f64 (+.f64 z #s(literal 1 binary64)) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) #s(literal 1 binary64))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
#s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (*.f64 z (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))
(.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x)))
(+.f64 (-.f64 #s(approx (+ (+ x y) z) (+.f64 z x)) (.f64 z (log.f64 t))) #s(approx ( (- a 1/2) b) #s(literal -1/2 binary64)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (-.f64 z (*.f64 z (log.f64 t)))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 (log.f64 t) (neg.f64 z) z)) #s(approx (* (- a 1/2) b) (*.f64 b a)))

Outputs

(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x)))

(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))

Calls

2 calls:

47.0ms	z
13.0ms	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)

Results

Accuracy	Segments	Branch
91.9%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
90.9%	4	`z`

Compiler

Compiled 18 to 15 computations (16.7% saved)

regimes180.0ms (1.2%)

Memory

-8.7MiB live, 276.7MiB allocated

Counts

45 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (*.f64 b #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (/.f64 #s(literal 1 binary64) b)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (fma.f64 x (/.f64 y x) x))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ y x) (fma.f64 x (/.f64 y x) x))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (*.f64 x x)))) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (.f64 x (*.f64 x x))))) (fma.f64 (/.f64 (+.f64 z #s(literal 1 binary64)) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) #s(literal 1 binary64))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
#s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (*.f64 z (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))
(.f64 (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (.f64 b (.f64 (+.f64 a #s(literal -1/2 binary64)) (.f64 b (+.f64 a #s(literal -1/2 binary64))))) (.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) (-.f64 (.f64 b (+.f64 a #s(literal -1/2 binary64))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (fma.f64 (log.f64 t) (neg.f64 z) #s(literal 1 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (log.f64 t))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log.f64 (+.f64 a (+.f64 z (+.f64 x #s(literal -1/2 binary64)))))))

Outputs

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))

(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))

Calls

11 calls:

29.0ms	y
25.0ms	(+.f64 x y)
17.0ms	a
15.0ms	t
14.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))

Results

Accuracy	Segments	Branch
76.4%	1	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
76.4%	1	`y`
84.9%	3	`z`
76.4%	1	`(+.f64 x y)`
76.4%	1	`(-.f64 a #s(literal 1/2 binary64))`
76.4%	1	`b`
76.4%	1	`t`
76.4%	1	`(log.f64 t)`
76.4%	1	`a`
76.4%	1	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
76.4%	1	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`

Compiler

Compiled 110 to 87 computations (20.9% saved)

regimes14.0ms (0.1%)

Memory

37.7MiB live, 37.7MiB allocated

Counts

40 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (*.f64 b #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (/.f64 #s(literal 1 binary64) b)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (fma.f64 x (/.f64 y x) x))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ y x) (fma.f64 x (/.f64 y x) x))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (*.f64 x x)))) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (.f64 x (*.f64 x x))))) (fma.f64 (/.f64 (+.f64 z #s(literal 1 binary64)) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) #s(literal 1 binary64))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))
#s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (*.f64 z (log.f64 t))))

Outputs

#s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (*.f64 z (log.f64 t))))

(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))

#s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (*.f64 z (log.f64 t))))

Calls

1 calls:

12.0ms

Results

Accuracy	Segments	Branch
84.9%	3	`z`

Compiler

Compiled 7 to 6 computations (14.3% saved)

regimes40.0ms (0.3%)

Memory

2.6MiB live, 77.3MiB allocated

Counts

39 → 1

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (*.f64 b #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (/.f64 #s(literal 1 binary64) b)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (fma.f64 x (/.f64 z x) #s(literal 1 binary64)))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (fma.f64 z (/.f64 (-.f64 #s(literal -1 binary64) x) z) (neg.f64 z))))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ x y) (fma.f64 x (/.f64 y x) x))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (neg.f64 (*.f64 x (-.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) #s(approx (+ y x) (fma.f64 x (/.f64 y x) x))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) #s(approx (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))))
(fma.f64 (.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 b (-.f64 a #s(literal -1/2 binary64)))) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64))) (*.f64 x x)))) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 x (-.f64 x y) (.f64 y y)) (fma.f64 x (.f64 x x) (.f64 y (.f64 y y)))))) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) (/.f64 (.f64 (neg.f64 x) (-.f64 #s(literal -1 binary64) (/.f64 (.f64 (+.f64 z #s(literal 1 binary64)) (.f64 (+.f64 z #s(literal 1 binary64)) (+.f64 z #s(literal 1 binary64)))) (.f64 x (*.f64 x x))))) (fma.f64 (/.f64 (+.f64 z #s(literal 1 binary64)) x) (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)) #s(literal 1 binary64))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (/.f64 #s(literal 1 binary64) (/.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (.f64 (+.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x))))) (-.f64 y #s(approx (log (+ 1 (+ z x))) (.f64 x (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 z #s(literal 1 binary64)) x)))))))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y (log1p.f64 (+.f64 z x))))

Outputs
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))

Calls

3 calls:

13.0ms	x
11.0ms	z
11.0ms	(+.f64 x y)

Results

Accuracy	Segments	Branch
76.4%	1	`(+.f64 x y)`
76.4%	1	`x`
76.4%	1	`z`

Compiler

Compiled 23 to 19 computations (17.4% saved)

regimes106.0ms (0.7%)

Memory

-9.5MiB live, 225.8MiB allocated

Counts

25 → 1

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (*.f64 b #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) (*.f64 (-.f64 a #s(literal 1/2 binary64)) b))

Outputs
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))

Calls

12 calls:

11.0ms	x
10.0ms	(+.f64 x y)
10.0ms	a
9.0ms	t
9.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))

Results

Accuracy	Segments	Branch
76.4%	1	`a`
76.4%	1	`z`
76.4%	1	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
76.4%	1	`x`
76.4%	1	`y`
76.4%	1	`t`
76.4%	1	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
76.4%	1	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
76.4%	1	`(log.f64 t)`
76.4%	1	`(-.f64 a #s(literal 1/2 binary64))`
76.4%	1	`b`
76.4%	1	`(+.f64 x y)`

Compiler

Compiled 117 to 93 computations (20.5% saved)

regimes107.0ms (0.7%)

Memory

-5.0MiB live, 204.4MiB allocated

Counts

23 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))
(fma.f64 b a #s(approx (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t)))) (*.f64 b #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 a (-.f64 z (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 z (-.f64 a (fma.f64 z t #s(literal 1/2 binary64)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 (+.f64 a z) (fma.f64 z t #s(literal 1/2 binary64))))

Outputs

(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))

(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))

(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))

Calls

12 calls:

18.0ms	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
10.0ms	z
9.0ms	(log.f64 t)
9.0ms	x
9.0ms	(+.f64 x y)

Results

Accuracy	Segments	Branch
76.0%	3	`a`
63.2%	1	`z`
69.9%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
63.2%	1	`x`
63.2%	1	`y`
63.2%	1	`t`
66.7%	3	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
63.2%	1	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
63.2%	1	`(log.f64 t)`
76.0%	3	`(-.f64 a #s(literal 1/2 binary64))`
70.4%	3	`b`
68.4%	3	`(+.f64 x y)`

Compiler

Compiled 117 to 93 computations (20.5% saved)

regimes32.0ms (0.2%)

Memory

0.9MiB live, 79.5MiB allocated

Counts

18 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))
(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))

Outputs

#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))

(fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))

Calls

4 calls:

12.0ms	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
7.0ms	(-.f64 a #s(literal 1/2 binary64))
6.0ms	a
6.0ms	b

Results

Accuracy	Segments	Branch
69.9%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
64.6%	3	`b`
66.0%	3	`a`
66.0%	3	`(-.f64 a #s(literal 1/2 binary64))`

Compiler

Compiled 34 to 29 computations (14.7% saved)

regimes80.0ms (0.5%)

Memory

11.9MiB live, 169.5MiB allocated

Counts

17 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))

Outputs

#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))

(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))

#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))

Calls

12 calls:

9.0ms	(-.f64 a #s(literal 1/2 binary64))
9.0ms	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
7.0ms	y
7.0ms	z
6.0ms	a

Results

Accuracy	Segments	Branch
58.3%	3	`b`
51.5%	3	`a`
51.5%	3	`(-.f64 a #s(literal 1/2 binary64))`
53.6%	3	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
50.8%	3	`x`
47.0%	3	`z`
45.9%	4	`t`
45.9%	4	`(log.f64 t)`
53.1%	3	`y`
54.3%	4	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
57.2%	3	`(+.f64 x y)`
62.7%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`

Compiler

Compiled 117 to 93 computations (20.5% saved)

regimes8.0ms (0.1%)

Memory

-21.5MiB live, 16.7MiB allocated

Counts

16 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 x (+.f64 z #s(literal 1 binary64)))))))

Outputs

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))

(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))

Calls

1 calls:

7.0ms

(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)

Results

Accuracy	Segments	Branch
62.7%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`

Compiler

Compiled 11 to 9 computations (18.2% saved)

regimes16.0ms (0.1%)

Memory

-2.6MiB live, 35.9MiB allocated

Counts

12 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))
(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal 1 binary64)))

Outputs

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))

(+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))

Calls

3 calls:

6.0ms	(+.f64 x y)
4.0ms	b
4.0ms	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)

Results

Accuracy	Segments	Branch
49.2%	3	`(+.f64 x y)`
49.0%	3	`b`
54.5%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`

Compiler

Compiled 27 to 22 computations (18.5% saved)

regimes54.0ms (0.3%)

Memory

10.8MiB live, 128.6MiB allocated

Counts

10 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (+.f64 z #s(literal 1 binary64))))))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 y (+.f64 #s(literal 1/2 binary64) a)))
#s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (+.f64 z (+.f64 a #s(literal -1/2 binary64))))

Outputs

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z)))))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))

Calls

12 calls:

8.0ms	x
5.0ms	(log.f64 t)
5.0ms	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
4.0ms	z
4.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))

Results

Accuracy	Segments	Branch
30.0%	2	`t`
30.0%	2	`(log.f64 t)`
30.1%	2	`z`
37.7%	3	`b`
39.3%	2	`(+.f64 x y)`
31.3%	2	`x`
41.6%	3	`(-.f64 a #s(literal 1/2 binary64))`
41.6%	3	`a`
43.8%	3	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
38.2%	2	`y`
37.0%	2	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
43.8%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`

Compiler

Compiled 117 to 93 computations (20.5% saved)

regimes6.0ms (0%)

Memory

16.2MiB live, 16.2MiB allocated

Counts

5 → 3

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))

Outputs

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))

Calls

2 calls:

2.0ms	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
2.0ms	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)

Results

Accuracy	Segments	Branch
42.2%	3	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
42.0%	3	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`

Compiler

Compiled 33 to 24 computations (27.3% saved)

regimes33.0ms (0.2%)

Memory

12.5MiB live, 85.7MiB allocated

Counts

4 → 1

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))

Outputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))

Calls

12 calls:

4.0ms	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
2.0ms	b
2.0ms	x
2.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
2.0ms	z

Results

Accuracy	Segments	Branch
21.8%	1	`t`
21.8%	1	`(log.f64 t)`
21.8%	1	`z`
21.8%	1	`x`
21.8%	1	`b`
21.8%	1	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
21.8%	1	`y`
21.8%	1	`(+.f64 x y)`
21.8%	1	`a`
21.8%	1	`(-.f64 a #s(literal 1/2 binary64))`
21.8%	1	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
21.8%	1	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`

Compiler

Compiled 117 to 93 computations (20.5% saved)

regimes36.0ms (0.2%)

Memory

-26.1MiB live, 68.7MiB allocated

Counts

3 → 1

Calls

Call 1

Inputs

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))

#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (+ y (+ a -1/2)) (+.f64 a #s(literal -1/2 binary64))))

Outputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))

Calls

12 calls:

13.0ms	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
3.0ms	(log.f64 t)
2.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))
2.0ms	t
2.0ms	a

Results

Accuracy	Segments	Branch
3.9%	1	`a`
3.9%	1	`y`
3.9%	1	`t`
3.9%	1	`b`
3.9%	1	`(log.f64 t)`
3.9%	1	`z`
3.9%	1	`(-.f64 a #s(literal 1/2 binary64))`
3.9%	1	`x`
3.9%	1	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
3.9%	1	`(+.f64 x y)`
3.9%	1	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
3.9%	1	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`

Compiler

Compiled 117 to 93 computations (20.5% saved)

regimes17.0ms (0.1%)

Memory

9.3MiB live, 48.3MiB allocated

Accuracy

Total 0.0b remaining (0%)

Threshold costs 0b (0%)

Counts

1 → 1

Calls

Call 1

Inputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))

Outputs
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))

Calls

12 calls:

2.0ms	t
1.0ms	(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)
1.0ms	(log.f64 t)
1.0ms	(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
1.0ms	(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))

Results

Accuracy	Segments	Branch
2.3%	1	`y`
2.3%	1	`a`
2.3%	1	`z`
2.3%	1	`(-.f64 (+.f64 (+.f64 x y) z) (*.f64 z (log.f64 t)))`
2.3%	1	`(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))`
2.3%	1	`(+.f64 x y)`
2.3%	1	`(-.f64 a #s(literal 1/2 binary64))`
2.3%	1	`x`
2.3%	1	`(*.f64 (-.f64 a #s(literal 1/2 binary64)) b)`
2.3%	1	`t`
2.3%	1	`(log.f64 t)`
2.3%	1	`b`

Compiler

Compiled 117 to 93 computations (20.5% saved)

bsearch1.0ms (0%)

Memory

1.4MiB live, 1.4MiB allocated

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-4.070299004576487e-62	-1.7819035758608106e-67

Compiler

Compiled 25 to 24 computations (4% saved)

bsearch43.0ms (0.3%)

Memory

-31.4MiB live, 88.5MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
20.0ms	3.682930473040596e-21	2.3359210419161024e-13
18.0ms	-1.5856904145711067e+40	-6.161795080501882e+32

Samples

27.0ms

288×

valid

Compiler

Compiled 691 to 474 computations (31.4% saved)

Precisions

Click to see histograms. Total time spent on operations: 18.0ms

ival-mult: 7.0ms (39.7% of total)

ival-log: 4.0ms (22.7% of total)

ival-add: 4.0ms (22.7% of total)

ival-sub: 2.0ms (11.4% of total)

ival-true: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

bsearch29.0ms (0.2%)

Memory

23.9MiB live, 62.4MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
16.0ms	3.1649996953906675e+91	1.852245412859515e+95
10.0ms	-1.5856904145711067e+40	-6.161795080501882e+32

Samples

17.0ms

208×

valid

Compiler

Compiled 654 to 432 computations (33.9% saved)

Precisions

Click to see histograms. Total time spent on operations: 10.0ms

ival-log: 3.0ms (29.9% of total)

ival-add: 3.0ms (29.9% of total)

ival-mult: 3.0ms (29.9% of total)

ival-sub: 2.0ms (19.9% of total)

ival-true: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

bsearch1.0ms (0%)

Memory

1.0MiB live, 1.0MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	1.1660283016007505e+46	6.901263036783623e+56
0.0ms	-1.9884875058864697e+113	-1.7012996304687727e+112

Compiler

Compiled 25 to 24 computations (4% saved)

bsearch41.0ms (0.3%)

Memory

-26.2MiB live, 94.7MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
18.0ms	2.583718365535326e+218	1.8818763567638557e+223
18.0ms	-4.345979261535142e+222	-3.6641511413653055e+214

Samples

25.0ms

288×

valid

Compiler

Compiled 583 to 402 computations (31% saved)

Precisions

Click to see histograms. Total time spent on operations: 15.0ms

ival-sub: 4.0ms (26.7% of total)

ival-log: 4.0ms (26.7% of total)

ival-add: 4.0ms (26.7% of total)

ival-mult: 4.0ms (26.7% of total)

ival-true: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

bsearch2.0ms (0%)

Memory

5.4MiB live, 5.4MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
1.0ms	2.583718365535326e+218	1.8818763567638557e+223
1.0ms	-4.345979261535142e+222	-3.6641511413653055e+214

Compiler

Compiled 583 to 402 computations (31% saved)

bsearch0.0ms (0%)

Memory

1.0MiB live, 1.0MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	-0.5	-0.49999986458310147
0.0ms	-45243800.258674555	-0.5000001263412615

Compiler

Compiled 25 to 24 computations (4% saved)

bsearch0.0ms (0%)

Memory

0.8MiB live, 0.8MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	1.1029371981983508e+206	3.795938599733532e+216
0.0ms	-3.749755798757235e+156	-2.4688576231885187e+148

Compiler

Compiled 25 to 24 computations (4% saved)

bsearch0.0ms (0%)

Memory

0.9MiB live, 0.9MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	2.695695879996645e+156	1.266660100911741e+166
0.0ms	-1.4167924196788307e+99	-3.201755464665604e+97

Compiler

Compiled 25 to 24 computations (4% saved)

bsearch0.0ms (0%)

Memory

1.1MiB live, 1.1MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	5.751261661599433e+171	2.897937934135815e+180
0.0ms	-3.201755464665604e+97	-3.8176224102481376e+95

Compiler

Compiled 25 to 24 computations (4% saved)

bsearch0.0ms (0%)

Memory

0.9MiB live, 0.9MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	1.1029371981983508e+206	3.795938599733532e+216
0.0ms	-3.749755798757235e+156	-2.4688576231885187e+148

Compiler

Compiled 25 to 24 computations (4% saved)

bsearch0.0ms (0%)

Memory

0.8MiB live, 0.8MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	5.751261661599433e+171	2.897937934135815e+180
0.0ms	-1.4689604648770938e+70	-2.516173667434025e+66

Compiler

Compiled 25 to 24 computations (4% saved)

bsearch0.0ms (0%)

Memory

0.6MiB live, 0.6MiB allocated

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	1.6612066438420332e+307	+inf
0.0ms	5.942183275045329e-7	0.5766666129379546

Compiler

Compiled 25 to 24 computations (4% saved)

simplify18.0ms (0.1%)

Memory

-4.3MiB live, 35.3MiB allocated

Algorithm

1×	egg-herbie

Rules

42×	`+-commutative_binary64`
22×	`*-commutative_binary64`
22×	`sub-neg_binary64`
12×	`neg-sub0_binary64`
12×	`neg-mul-1_binary64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	164	1246
1	201	1246
2	223	1246
3	233	1246
4	237	1246

Stop Event

1×

saturated

Calls

Call 1

Inputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (fma.f64 b a (.f64 b #s(literal -1/2 binary64))))
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b))
(if (<=.f64 (+.f64 x y) #s(literal -578960446186581/14474011154664524427946373126085988481658748083205070504932198000989141204992 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))))
(if (<=.f64 z #s(literal -5600000000000000119496407222759456768 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))) (if (<=.f64 z #s(literal 1064628433785427/4951760157141521099596496896 binary64)) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))))
(if (<=.f64 z #s(literal -23999999999999999837503676259019784192 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (.f64 b a))) (if (<=.f64 z #s(literal 3400000000000000031690720476389037225616012296148685806822046218102233124367331769287371128832 binary64)) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -100000000000000001555941612946684302426820139692106143336977058043083378116475570326498538991504744767620628086784 binary64)) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 19999999999999999862796380718940425895318388736 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
(if (<=.f64 z #s(literal -36999999999999998075247901067307792377735216102091155751112794604598519029923035435490394894632251280685369136101393803404156554563512898158175824077301078827425648467095303540305947157799116644247413089169221615616 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z)) (if (<=.f64 z #s(literal 370000000000000001190007822321678402919165554368376782627313664171582247319885854582365477173180568729477956235569406558446900805136487495770494842259400072749359734736133900432816152630008944675956856738886966126313472 binary64)) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))))
(if (<=.f64 z #s(literal -36999999999999998075247901067307792377735216102091155751112794604598519029923035435490394894632251280685369136101393803404156554563512898158175824077301078827425648467095303540305947157799116644247413089169221615616 binary64)) #s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (.f64 z (log.f64 t)))) (if (<=.f64 z #s(literal 370000000000000001190007822321678402919165554368376782627313664171582247319885854582365477173180568729477956235569406558446900805136487495770494842259400072749359734736133900432816152630008944675956856738886966126313472 binary64)) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))) #s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (*.f64 z (log.f64 t))))))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(if (<=.f64 (-.f64 a #s(literal 1/2 binary64)) #s(literal -40000000 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (.f64 b a))) (if (<=.f64 (-.f64 a #s(literal 1/2 binary64)) #s(literal -1/2 binary64)) (fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -1999999999999999966718360446383443429120744550034941072734015228920936835002025109062955753891877483502474776688726210135069014696329147466931020740652171264 binary64)) #s(approx (/ 1 (/ 1 (+ ( (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 200000000000000007778715510217677686261474498590404026668604764015382588578769793526159931215755402774652920623882426582706341222818875123308036734442537880708869172525233887089132911615311892438644481327104 binary64)) (fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -999999999999999967336168804116691273849533185806555472917961779471295845921727862608739868455469056 binary64)) #s(approx (/ 1 (/ 1 (+ ( (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 4999999999999999916795901115958608572801861375087352681835038072302342087505062772657389384729693708756186941721815525337672536740822868667327551851630428160 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) #s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -20000000000000001471517476954224996795152124304354913598491715802703518287604380404101359312306176 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 10000000000000000826871628571058023676436276965152235336326534308832671394311356729372731664122173896717192642523265688348930066834399772699475577180106550229078889679814656 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -1999999999999999966718360446383443429120744550034941072734015228920936835002025109062955753891877483502474776688726210135069014696329147466931020740652171264 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (.f64 b a)) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 200000000000000007778715510217677686261474498590404026668604764015382588578769793526159931215755402774652920623882426582706341222818875123308036734442537880708869172525233887089132911615311892438644481327104 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -10000000000000000725314363815292351261583744096465219555182101554790400 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (.f64 b a)) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 10000000000000000826871628571058023676436276965152235336326534308832671394311356729372731664122173896717192642523265688348930066834399772699475577180106550229078889679814656 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z))))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))))
(if (<=.f64 (+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) #s(literal 4722366482869645/4722366482869645213696 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (.f64 b a)) (if (<=.f64 (+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) #s(literal 19999999999999999720621195205129155434005283676252727750499321471767131705345487698129692828457921333572758560785309230786706345700504206672551904741230794021461383329378750357138079702146292679283246532142253440022040339106608037192915625377123894402342976922345843644278133859702564244005353335500042141696 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64)))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))

Outputs
(+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (fma.f64 b a (.f64 b #s(literal -1/2 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 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 b (-.f64 a #s(literal 1/2 binary64))))
(if (<=.f64 (+.f64 x y) #s(literal -578960446186581/14474011154664524427946373126085988481658748083205070504932198000989141204992 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x)) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))))
(if (<=.f64 (+.f64 x y) #s(literal -578960446186581/14474011154664524427946373126085988481658748083205070504932198000989141204992 binary64)) (+.f64 (.f64 b (-.f64 a #s(literal 1/2 binary64))) #s(approx (- (+ (+ x y) z) ( z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) x))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))))
(if (<=.f64 z #s(literal -5600000000000000119496407222759456768 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y))) (if (<=.f64 z #s(literal 1064628433785427/4951760157141521099596496896 binary64)) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)))))
(if (<=.f64 z #s(literal -23999999999999999837503676259019784192 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (.f64 b a))) (if (<=.f64 z #s(literal 3400000000000000031690720476389037225616012296148685806822046218102233124367331769287371128832 binary64)) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) y)) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -100000000000000001555941612946684302426820139692106143336977058043083378116475570326498538991504744767620628086784 binary64)) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 19999999999999999862796380718940425895318388736 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 y x))) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
(if (<=.f64 (.f64 b (-.f64 a #s(literal 1/2 binary64))) #s(literal -100000000000000001555941612946684302426820139692106143336977058043083378116475570326498538991504744767620628086784 binary64)) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))) (if (<=.f64 (.f64 b (-.f64 a #s(literal 1/2 binary64))) #s(literal 19999999999999999862796380718940425895318388736 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 z (-.f64 #s(literal 1 binary64) (log.f64 t)) (+.f64 x y))) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))))
(if (<=.f64 z #s(literal -36999999999999998075247901067307792377735216102091155751112794604598519029923035435490394894632251280685369136101393803404156554563512898158175824077301078827425648467095303540305947157799116644247413089169221615616 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z)) (if (<=.f64 z #s(literal 370000000000000001190007822321678402919165554368376782627313664171582247319885854582365477173180568729477956235569406558446900805136487495770494842259400072749359734736133900432816152630008944675956856738886966126313472 binary64)) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (+ (* b a) (* b -1/2))) (fma.f64 (log.f64 t) (neg.f64 z) z))))
(if (<=.f64 z #s(literal -36999999999999998075247901067307792377735216102091155751112794604598519029923035435490394894632251280685369136101393803404156554563512898158175824077301078827425648467095303540305947157799116644247413089169221615616 binary64)) #s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (.f64 z (log.f64 t)))) (if (<=.f64 z #s(literal 370000000000000001190007822321678402919165554368376782627313664171582247319885854582365477173180568729477956235569406558446900805136487495770494842259400072749359734736133900432816152630008944675956856738886966126313472 binary64)) (fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))) #s(approx (+ (* b a) (+ (* b -1/2) (- (+ (+ x y) z) (* z (log t))))) (-.f64 z (*.f64 z (log.f64 t))))))
(fma.f64 b a (fma.f64 b #s(literal -1/2 binary64) #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))))
(fma.f64 (+.f64 a #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)))
(if (<=.f64 (-.f64 a #s(literal 1/2 binary64)) #s(literal -40000000 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (.f64 b a))) (if (<=.f64 (-.f64 a #s(literal 1/2 binary64)) #s(literal -1/2 binary64)) (fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) (*.f64 b a)))))
(if (<=.f64 (-.f64 a #s(literal 1/2 binary64)) #s(literal -40000000 binary64)) (+.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) (if (<=.f64 (-.f64 a #s(literal 1/2 binary64)) #s(literal -1/2 binary64)) (fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y))) (+.f64 #s(approx (* (- a 1/2) b) (.f64 b a)) #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -1999999999999999966718360446383443429120744550034941072734015228920936835002025109062955753891877483502474776688726210135069014696329147466931020740652171264 binary64)) #s(approx (/ 1 (/ 1 (+ ( (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 200000000000000007778715510217677686261474498590404026668604764015382588578769793526159931215755402774652920623882426582706341222818875123308036734442537880708869172525233887089132911615311892438644481327104 binary64)) (fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(if (<=.f64 (.f64 b (-.f64 a #s(literal 1/2 binary64))) #s(literal -1999999999999999966718360446383443429120744550034941072734015228920936835002025109062955753891877483502474776688726210135069014696329147466931020740652171264 binary64)) #s(approx (/ 1 (/ 1 (+ ( (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)) (if (<=.f64 (.f64 b (-.f64 a #s(literal 1/2 binary64))) #s(literal 200000000000000007778715510217677686261474498590404026668604764015382588578769793526159931215755402774652920623882426582706341222818875123308036734442537880708869172525233887089132911615311892438644481327104 binary64)) (fma.f64 #s(approx (+ a -1/2) #s(literal -1/2 binary64)) b #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -999999999999999967336168804116691273849533185806555472917961779471295845921727862608739868455469056 binary64)) #s(approx (/ 1 (/ 1 (+ ( (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 4999999999999999916795901115958608572801861375087352681835038072302342087505062772657389384729693708756186941721815525337672536740822868667327551851630428160 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) #s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))))
(if (<=.f64 (.f64 b (-.f64 a #s(literal 1/2 binary64))) #s(literal -999999999999999967336168804116691273849533185806555472917961779471295845921727862608739868455469056 binary64)) #s(approx (/ 1 (/ 1 (+ ( (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z)) (if (<=.f64 (.f64 b (-.f64 a #s(literal 1/2 binary64))) #s(literal 4999999999999999916795901115958608572801861375087352681835038072302342087505062772657389384729693708756186941721815525337672536740822868667327551851630428160 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) ( z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) #s(approx (/ 1 (/ 1 (+ (* (+ a -1/2) b) (+ (* (log t) (neg z)) (+ x (+ y z)))))) (fma.f64 b (+.f64 a #s(literal -1/2 binary64)) z))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -20000000000000001471517476954224996795152124304354913598491715802703518287604380404101359312306176 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 10000000000000000826871628571058023676436276965152235336326534308832671394311356729372731664122173896717192642523265688348930066834399772699475577180106550229078889679814656 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(if (<=.f64 (.f64 b (-.f64 a #s(literal 1/2 binary64))) #s(literal -20000000000000001471517476954224996795152124304354913598491715802703518287604380404101359312306176 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (.f64 b (+.f64 a #s(literal -1/2 binary64)))) (if (<=.f64 (.f64 b (-.f64 a #s(literal 1/2 binary64))) #s(literal 10000000000000000826871628571058023676436276965152235336326534308832671394311356729372731664122173896717192642523265688348930066834399772699475577180106550229078889679814656 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b (+.f64 a #s(literal -1/2 binary64))))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -1999999999999999966718360446383443429120744550034941072734015228920936835002025109062955753891877483502474776688726210135069014696329147466931020740652171264 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (.f64 b a)) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 200000000000000007778715510217677686261474498590404026668604764015382588578769793526159931215755402774652920623882426582706341222818875123308036734442537880708869172525233887089132911615311892438644481327104 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 y x)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))))
(if (<=.f64 (.f64 b (-.f64 a #s(literal 1/2 binary64))) #s(literal -1999999999999999966718360446383443429120744550034941072734015228920936835002025109062955753891877483502474776688726210135069014696329147466931020740652171264 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (.f64 b a)) (if (<=.f64 (.f64 b (-.f64 a #s(literal 1/2 binary64))) #s(literal 200000000000000007778715510217677686261474498590404026668604764015382588578769793526159931215755402774652920623882426582706341222818875123308036734442537880708869172525233887089132911615311892438644481327104 binary64)) (+.f64 #s(approx (- (+ (+ x y) z) (* z (log t))) (+.f64 x y)) #s(approx (* (- a 1/2) b) #s(literal -1/2 binary64))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))))
(if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal -10000000000000000725314363815292351261583744096465219555182101554790400 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (.f64 b a)) (if (<=.f64 (.f64 (-.f64 a #s(literal 1/2 binary64)) b) #s(literal 10000000000000000826871628571058023676436276965152235336326534308832671394311356729372731664122173896717192642523265688348930066834399772699475577180106550229078889679814656 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z))))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))))
(if (<=.f64 (.f64 b (-.f64 a #s(literal 1/2 binary64))) #s(literal -10000000000000000725314363815292351261583744096465219555182101554790400 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (.f64 b a)) (if (<=.f64 (.f64 b (-.f64 a #s(literal 1/2 binary64))) #s(literal 10000000000000000826871628571058023676436276965152235336326534308832671394311356729372731664122173896717192642523265688348930066834399772699475577180106550229078889679814656 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (-.f64 y #s(approx (log (+ 1 (+ z x))) #s(approx (neg (* x (- -1 (/ (+ z 1) x)))) (neg.f64 z))))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))))
(if (<=.f64 (+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) #s(literal 4722366482869645/4722366482869645213696 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (.f64 b a)) (if (<=.f64 (+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 (-.f64 a #s(literal 1/2 binary64)) b)) #s(literal 19999999999999999720621195205129155434005283676252727750499321471767131705345487698129692828457921333572758560785309230786706345700504206672551904741230794021461383329378750357138079702146292679283246532142253440022040339106608037192915625377123894402342976922345843644278133859702564244005353335500042141696 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64)))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))))
(if (<=.f64 (+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 b (-.f64 a #s(literal 1/2 binary64)))) #s(literal 4722366482869645/4722366482869645213696 binary64)) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (.f64 b a)) (if (<=.f64 (+.f64 (-.f64 (+.f64 (+.f64 x y) z) (.f64 z (log.f64 t))) (.f64 b (-.f64 a #s(literal 1/2 binary64)))) #s(literal 19999999999999999720621195205129155434005283676252727750499321471767131705345487698129692828457921333572758560785309230786706345700504206672551904741230794021461383329378750357138079702146292679283246532142253440022040339106608037192915625377123894402342976922345843644278133859702564244005353335500042141696 binary64)) #s(approx (+ (- (+ (+ x y) z) ( z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64)))) #s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (*.f64 b a))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) (+.f64 y #s(approx (+ a -1/2) #s(literal -1/2 binary64))))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 z)))
#s(approx (+ (- (+ (+ x y) z) (* z (log t))) (* (- a 1/2) b)) #s(approx (- y (log (+ 1 (+ z x)))) (neg.f64 x)))

soundness1.5s (9.9%)

Memory

23.5MiB live, 1 107.1MiB allocated

Rules

10 248×	`lower-fma.f64`
10 248×	`lower-fma.f32`
10 038×	`lower-fma.f64`
10 038×	`lower-fma.f32`
8 850×	`lower-fma.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	15	45
0	23	45
1	105	45
2	948	45
0	8252	44
0	694	12008
1	2124	11688
2	6386	11622
0	8006	10972
0	35	169
0	52	167
1	212	167
2	1864	167
0	8430	164
0	355	2673
1	1051	2646
2	3268	2610
0	8328	2468
0	645	12257
1	1976	12000
2	6286	11909
0	8053	11136
0	437	9455
1	1313	9378
2	4258	9228
0	8056	8675

Stop Event

1×	fuel
1×	iter limit
1×	node limit
1×	iter limit
1×	node limit
1×	iter limit
1×	node limit
1×	iter limit
1×	node limit
1×	iter limit
1×	iter limit
1×	node limit
1×	iter limit
1×	node limit
1×	iter limit

Compiler

Compiled 1 668 to 813 computations (51.3% saved)

preprocess158.0ms (1%)

Memory: -18.4MiB live, 290.9MiB allocated
Remove: (sort x y)
Compiler: Compiled 1 318 to 344 computations (73.9% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

start0.0ms (0%)

analyze3.0ms (0%)

sample1.2s (7.5%)

explain154.0ms (1%)

preprocess636.0ms (4.1%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify712.0ms (4.6%)

localize39.0ms (0.2%)

series319.0ms (2.1%)

simplify344.0ms (2.2%)

rewrite391.0ms (2.5%)

eval151.0ms (1%)

prune156.0ms (1%)

simplify419.0ms (2.7%)

localize129.0ms (0.8%)

series468.0ms (3%)

simplify473.0ms (3%)

rewrite335.0ms (2.2%)

eval216.0ms (1.4%)

prune295.0ms (1.9%)

simplify264.0ms (1.7%)

localize188.0ms (1.2%)

series695.0ms (4.5%)

simplify693.0ms (4.5%)

rewrite824.0ms (5.3%)

eval251.0ms (1.6%)

prune263.0ms (1.7%)

simplify279.0ms (1.8%)

localize132.0ms (0.8%)

series495.0ms (3.2%)

simplify398.0ms (2.6%)

rewrite442.0ms (2.8%)

eval179.0ms (1.1%)

prune213.0ms (1.4%)

regimes484.0ms (3.1%)

regimes262.0ms (1.7%)

regimes243.0ms (1.6%)

regimes137.0ms (0.9%)

regimes76.0ms (0.5%)

regimes84.0ms (0.5%)

regimes180.0ms (1.2%)

regimes14.0ms (0.1%)

regimes40.0ms (0.3%)

regimes106.0ms (0.7%)

regimes107.0ms (0.7%)

regimes32.0ms (0.2%)

regimes80.0ms (0.5%)

regimes8.0ms (0.1%)

regimes16.0ms (0.1%)

regimes54.0ms (0.3%)

regimes6.0ms (0%)

regimes33.0ms (0.2%)

regimes36.0ms (0.2%)

regimes17.0ms (0.1%)

bsearch1.0ms (0%)

bsearch43.0ms (0.3%)

bsearch29.0ms (0.2%)

bsearch1.0ms (0%)

bsearch41.0ms (0.3%)

bsearch2.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

simplify18.0ms (0.1%)

soundness1.5s (9.9%)

preprocess158.0ms (1%)

end0.0ms (0%)

Profiling