Metrics for Commute and associate

start0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

analyze0.0ms (0%)

Memory

0.2MiB live, 0.2MiB allocated

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
0%	0%	99.9%	0.1%	0%	0%	0%	0
100%	99.9%	0%	0.1%	0%	0%	0%	1

Compiler

Compiled 13 to 10 computations (23.1% saved)

sample1.7s (42.8%)

Memory

39.6MiB live, 1 380.2MiB allocated

Samples

826.0ms	3 947×	2	valid
565.0ms	4 305×	1	valid
0.0ms	4×	0	valid

Precisions

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

ival-add: 442.0ms (46.4% of total)

adjust: 415.0ms (43.6% of total)

ival-sub: 87.0ms (9.1% of total)

ival-true: 5.0ms (0.5% of total)

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

Bogosity

explain136.0ms (3.4%)

Memory

17.3MiB live, 144.7MiB allocated

FPErrors

Click to see full error table

Example	Example	Subexpression
-	-	`(+.f64 (+.f64 x y) z)`
-	-	`(+.f64 y z)`
-	-	`y`
-	-	`(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))`
-	-	`(+.f64 x y)`
-	-	`(+.f64 x (+.f64 y z))`
-	-	`z`
-	-	`x`

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

47.0ms	248×	2	valid
31.0ms	264×	1	valid

Compiler

Compiled 75 to 28 computations (62.7% saved)

Precisions

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

ival-add: 25.0ms (46.6% of total)

adjust: 23.0ms (42.9% of total)

ival-sub: 5.0ms (9.3% of total)

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

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

preprocess412.0ms (10.2%)

Memory

-23.6MiB live, 110.0MiB allocated

Algorithm

1×	egg-herbie

Rules

14 508×	`lower-fma.f64`
14 508×	`lower-fma.f32`
3 456×	`unsub-neg`
3 206×	`associate-+r+`
2 832×	`lower-+.f32`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	36	117
1	122	9
2	525	9
3	1660	9
4	2510	9
5	2766	9
6	2777	9
7	2785	9
8	2785	9
9	2785	9
10	2785	9
11	2785	9
0	8	11
0	13	11
1	26	1
2	90	1
3	361	1
4	1162	1
5	1808	1
6	3880	1
7	5044	1
8	5872	1
9	6326	1
10	6360	1
11	6364	1
12	6482	1
13	6491	1
14	6492	1
15	6492	1
16	6492	1
17	7341	1
18	7493	1
19	7645	1
20	7759	1
21	7797	1
22	7797	1
0	8181	1

Stop Event

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

Calls

Call 1

Inputs
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))

Outputs
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
#s(literal 0 binary64)

Symmetry

(abs z)

(abs y)

(abs x)

(negabs z)

(negabs y)

(negabs x)

(sort x y z)

Compiler

Compiled 11 to 8 computations (27.3% saved)

eval0.0ms (0%)

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

prune0.0ms (0%)

Memory

0.9MiB live, 0.9MiB allocated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	100.0%	(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))

Compiler

Compiled 11 to 8 computations (27.3% saved)

simplify288.0ms (7.1%)

Memory

1.9MiB live, 63.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

New	Metric	Score
cost-diff	0	(+.f64 x (+.f64 y z))
cost-diff	0	(+.f64 x y)
cost-diff	0	(+.f64 (+.f64 x y) z)
cost-diff	960	(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))

Rules

14 508×	`lower-fma.f64`
14 508×	`lower-fma.f32`
3 456×	`unsub-neg`
2 832×	`lower-+.f32`
2 824×	`lower-+.f64`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	8	30
0	13	30
1	26	20
2	90	20
3	361	20
4	1162	20
5	1808	20
6	3880	20
7	5044	20
8	5872	20
9	6326	20
10	6360	20
11	6364	20
12	6482	20
13	6491	20
14	6492	20
15	6492	20
16	6492	20
17	7341	20
18	7493	20
19	7645	20
20	7759	20
21	7797	20
22	7797	20
0	8181	20

Stop Event

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

Calls

Call 1

Inputs
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(+.f64 x (+.f64 y z))
(+.f64 y z)

Outputs
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
#s(literal 0 binary64)
(+.f64 (+.f64 x y) z)
(+.f64 (+.f64 z y) x)
(+.f64 x y)
(+.f64 y x)
x
y
z
(+.f64 x (+.f64 y z))
(+.f64 (+.f64 z y) x)
(+.f64 y z)
(+.f64 z y)

localize42.0ms (1%)

Memory

17.1MiB live, 17.1MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score	Program
accuracy	0	(+.f64 (+.f64 x y) z)
accuracy	0	(+.f64 y z)
accuracy	0	(+.f64 x (+.f64 y z))
accuracy	0	(+.f64 x y)

Samples

20.0ms	124×	2	valid
14.0ms	132×	1	valid

Compiler

Compiled 32 to 10 computations (68.8% saved)

Precisions

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

adjust: 11.0ms (47.7% of total)

ival-add: 10.0ms (43.4% of total)

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

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

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

series5.0ms (0.1%)

Memory

6.2MiB live, 6.2MiB allocated

Counts

5 → 156

Calls

Call 1

Inputs
#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())
#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())
#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())
#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())
#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())

Outputs
#s(alt 0 (taylor 0 z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ x y) (taylor 0 z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x y) (taylor 0 z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt y (taylor 0 z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ x z) (/ y z)))) (taylor inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ x z) (/ y z)))) (taylor inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ x z) (/ y z)))) (taylor inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ x z) (/ y z)))) (taylor inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ x z) (/ y z)))) (taylor inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ x z) (/ y z)))) (taylor inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (/ y z))) (taylor inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (/ y z))) (taylor inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (/ y z))) (taylor inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1))) (taylor -inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1))) (taylor -inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1))) (taylor -inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ y z)) 1))) (taylor -inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ y z)) 1))) (taylor -inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ y z)) 1))) (taylor -inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ x z) (taylor 0 y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (+ x y) (taylor 0 y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (+ x y) (taylor 0 y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (+ x y) (taylor 0 y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (+ x z) (taylor 0 y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt z (taylor 0 y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt y (taylor inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (+ (/ x y) (/ z y)))) (taylor inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (+ (/ x y) (/ z y)))) (taylor inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (+ (/ x y) (/ z y)))) (taylor inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt y (taylor inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (/ x y))) (taylor inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (/ x y))) (taylor inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (/ x y))) (taylor inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt y (taylor inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (+ (/ x y) (/ z y)))) (taylor inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (+ (/ x y) (/ z y)))) (taylor inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (+ (/ x y) (/ z y)))) (taylor inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt y (taylor inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (/ z y))) (taylor inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (/ z y))) (taylor inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (/ z y))) (taylor inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt y (taylor -inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1))) (taylor -inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1))) (taylor -inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1))) (taylor -inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt y (taylor -inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ x y)) 1))) (taylor -inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ x y)) 1))) (taylor -inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ x y)) 1))) (taylor -inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt y (taylor -inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1))) (taylor -inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1))) (taylor -inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1))) (taylor -inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt y (taylor -inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ z y)) 1))) (taylor -inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ z y)) 1))) (taylor -inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ z y)) 1))) (taylor -inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt y (taylor 0 x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (+ x y) (taylor 0 x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (+ x y) (taylor 0 x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (+ x y) (taylor 0 x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (/ y x) (/ z x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (/ y x) (/ z x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (/ y x) (/ z x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (/ y x))) (taylor inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (/ y x))) (taylor inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (/ y x))) (taylor inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (/ y x) (/ z x)))) (taylor inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (/ y x) (/ z x)))) (taylor inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (/ y x) (/ z x)))) (taylor inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt x (taylor -inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1))) (taylor -inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1))) (taylor -inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1))) (taylor -inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt x (taylor -inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ y x)) 1))) (taylor -inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ y x)) 1))) (taylor -inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ y x)) 1))) (taylor -inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt x (taylor -inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1))) (taylor -inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1))) (taylor -inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1))) (taylor -inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())

Calls

9 calls:

Time	Variable		Point	Expression
0.0ms	z	@	inf	((- (+ (+ x y) z) (+ x (+ y z))) (+ (+ x y) z) (+ x y) (+ x (+ y z)) (+ y z))
0.0ms	y	@	-inf	((- (+ (+ x y) z) (+ x (+ y z))) (+ (+ x y) z) (+ x y) (+ x (+ y z)) (+ y z))
0.0ms	z	@	-inf	((- (+ (+ x y) z) (+ x (+ y z))) (+ (+ x y) z) (+ x y) (+ x (+ y z)) (+ y z))
0.0ms	y	@	inf	((- (+ (+ x y) z) (+ x (+ y z))) (+ (+ x y) z) (+ x y) (+ x (+ y z)) (+ y z))
0.0ms	x	@	inf	((- (+ (+ x y) z) (+ x (+ y z))) (+ (+ x y) z) (+ x y) (+ x (+ y z)) (+ y z))

simplify195.0ms (4.8%)

Memory

-11.9MiB live, 84.2MiB allocated

Algorithm

1×	egg-herbie

Rules

15 312×	`lower-fma.f64`
15 312×	`lower-fma.f32`
5 296×	`lower-/.f32`
5 296×	`lower-/.f64`
2 424×	`lower-*.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	64	456
1	188	456
2	475	456
3	1436	456
4	3501	456
5	4422	456
6	4929	456
7	5060	456
8	5078	456
9	5078	456
0	8926	456

Stop Event

1×	iter limit
1×	node limit

Counts

156 → 132

Calls

Call 1

Inputs
0
0
0
0
(+ x y)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
(+ x y)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
y
(+ y z)
(+ y z)
(+ y z)
0
0
0
0
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
z
(* z (+ 1 (/ y z)))
(* z (+ 1 (/ y z)))
(* z (+ 1 (/ y z)))
0
0
0
0
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
z
(* -1 (* z (- (* -1 (/ y z)) 1)))
(* -1 (* z (- (* -1 (/ y z)) 1)))
(* -1 (* z (- (* -1 (/ y z)) 1)))
0
0
0
0
(+ x z)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
x
(+ x y)
(+ x y)
(+ x y)
(+ x z)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
z
(+ y z)
(+ y z)
(+ y z)
0
0
0
0
y
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
y
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
y
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
y
(* y (+ 1 (/ z y)))
(* y (+ 1 (/ z y)))
(* y (+ 1 (/ z y)))
0
0
0
0
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
y
(* -1 (* y (- (* -1 (/ z y)) 1)))
(* -1 (* y (- (* -1 (/ z y)) 1)))
(* -1 (* y (- (* -1 (/ z y)) 1)))
0
0
0
0
(+ y z)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
y
(+ x y)
(+ x y)
(+ x y)
(+ y z)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
0
0
0
0
x
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
x
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
x
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
0
0
0
0
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))

Outputs
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
(+ x y)
(+.f64 y x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
(+ x y)
(+.f64 y x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
y
(+ y z)
(+.f64 z y)
(+ y z)
(+.f64 z y)
(+ y z)
(+.f64 z y)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(+.f64 (+.f64 z y) x)
(* z (+ 1 (+ (/ x z) (/ y z))))
(+.f64 (+.f64 z y) x)
(* z (+ 1 (+ (/ x z) (/ y z))))
(+.f64 (+.f64 z y) x)
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(+.f64 (+.f64 z y) x)
(* z (+ 1 (+ (/ x z) (/ y z))))
(+.f64 (+.f64 z y) x)
(* z (+ 1 (+ (/ x z) (/ y z))))
(+.f64 (+.f64 z y) x)
z
(* z (+ 1 (/ y z)))
(+.f64 z y)
(* z (+ 1 (/ y z)))
(+.f64 z y)
(* z (+ 1 (/ y z)))
(+.f64 z y)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(+.f64 (+.f64 z y) x)
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(+.f64 (+.f64 z y) x)
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(+.f64 (+.f64 z y) x)
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(+.f64 (+.f64 z y) x)
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(+.f64 (+.f64 z y) x)
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(+.f64 (+.f64 z y) x)
z
(* -1 (* z (- (* -1 (/ y z)) 1)))
(+.f64 z y)
(* -1 (* z (- (* -1 (/ y z)) 1)))
(+.f64 z y)
(* -1 (* z (- (* -1 (/ y z)) 1)))
(+.f64 z y)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
(+ x z)
(+.f64 z x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
x
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x z)
(+.f64 z x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
z
(+ y z)
(+.f64 z y)
(+ y z)
(+.f64 z y)
(+ y z)
(+.f64 z y)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
y
(* y (+ 1 (+ (/ x y) (/ z y))))
(+.f64 (+.f64 z y) x)
(* y (+ 1 (+ (/ x y) (/ z y))))
(+.f64 (+.f64 z y) x)
(* y (+ 1 (+ (/ x y) (/ z y))))
(+.f64 (+.f64 z y) x)
y
(* y (+ 1 (/ x y)))
(+.f64 y x)
(* y (+ 1 (/ x y)))
(+.f64 y x)
(* y (+ 1 (/ x y)))
(+.f64 y x)
y
(* y (+ 1 (+ (/ x y) (/ z y))))
(+.f64 (+.f64 z y) x)
(* y (+ 1 (+ (/ x y) (/ z y))))
(+.f64 (+.f64 z y) x)
(* y (+ 1 (+ (/ x y) (/ z y))))
(+.f64 (+.f64 z y) x)
y
(* y (+ 1 (/ z y)))
(+.f64 z y)
(* y (+ 1 (/ z y)))
(+.f64 z y)
(* y (+ 1 (/ z y)))
(+.f64 z y)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+.f64 (+.f64 z y) x)
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+.f64 (+.f64 z y) x)
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+.f64 (+.f64 z y) x)
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+.f64 y x)
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+.f64 y x)
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+.f64 y x)
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+.f64 (+.f64 z y) x)
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+.f64 (+.f64 z y) x)
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+.f64 (+.f64 z y) x)
y
(* -1 (* y (- (* -1 (/ z y)) 1)))
(+.f64 z y)
(* -1 (* y (- (* -1 (/ z y)) 1)))
(+.f64 z y)
(* -1 (* y (- (* -1 (/ z y)) 1)))
(+.f64 z y)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
(+ y z)
(+.f64 z y)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
y
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ y z)
(+.f64 z y)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
(+ x (+ y z))
(+.f64 (+.f64 z y) x)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
x
(* x (+ 1 (+ (/ y x) (/ z x))))
(+.f64 (+.f64 z y) x)
(* x (+ 1 (+ (/ y x) (/ z x))))
(+.f64 (+.f64 z y) x)
(* x (+ 1 (+ (/ y x) (/ z x))))
(+.f64 (+.f64 z y) x)
x
(* x (+ 1 (/ y x)))
(+.f64 y x)
(* x (+ 1 (/ y x)))
(+.f64 y x)
(* x (+ 1 (/ y x)))
(+.f64 y x)
x
(* x (+ 1 (+ (/ y x) (/ z x))))
(+.f64 (+.f64 z y) x)
(* x (+ 1 (+ (/ y x) (/ z x))))
(+.f64 (+.f64 z y) x)
(* x (+ 1 (+ (/ y x) (/ z x))))
(+.f64 (+.f64 z y) x)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+.f64 (+.f64 z y) x)
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+.f64 (+.f64 z y) x)
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+.f64 (+.f64 z y) x)
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(+.f64 y x)
(* -1 (* x (- (* -1 (/ y x)) 1)))
(+.f64 y x)
(* -1 (* x (- (* -1 (/ y x)) 1)))
(+.f64 y x)
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+.f64 (+.f64 z y) x)
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+.f64 (+.f64 z y) x)
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+.f64 (+.f64 z y) x)

rewrite147.0ms (3.7%)

Memory

1.7MiB live, 100.0MiB allocated

Rules

5 110×	`lower-*.f64`
5 110×	`lower-*.f32`
4 104×	`lower-fma.f64`
4 104×	`lower-fma.f32`
3 852×	`lower-/.f64`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	8	27
0	13	27
1	86	17
2	964	17
0	8446	17

Stop Event

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

Counts

5 → 209

Calls

Call 1

Inputs
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
(+.f64 x (+.f64 y z))
(+.f64 y z)

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

eval32.0ms (0.8%)

Memory: -14.5MiB live, 43.4MiB allocated
Compiler: Compiled 6 447 to 634 computations (90.2% saved)

prune8.0ms (0.2%)

Memory

17.8MiB live, 17.8MiB allocated

Pruning

1 alts after pruning (1 fresh and 0 done)

	Pruned	Kept	Total
New	340	1	341
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	341	1	342

Accuracy

100.0%

Counts

342 → 1

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	100.0%	#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))

Compiler

Compiled 2 to 5 computations (-150% saved)

simplify313.0ms (7.8%)

Memory

-12.2MiB live, 58.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 1 expressions of interest:

New	Metric	Score	Program
cost-diff	0	#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))

Rules

14 508×	`lower-fma.f64`
14 508×	`lower-fma.f32`
3 456×	`unsub-neg`
2 832×	`lower-+.f64`
2 832×	`lower-+.f32`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	10	14
0	10	14
1	22	4
2	86	4
3	353	4
4	1176	4
5	1819	4
6	3881	4
7	5015	4
8	5842	4
9	6296	4
10	6330	4
11	6334	4
12	6452	4
13	6461	4
14	6462	4
15	6462	4
16	6462	4
17	7311	4
18	7463	4
19	7615	4
20	7729	4
21	7767	4
22	7767	4
0	8151	4

Stop Event

1×	iter limit
1×	node limit
1×	saturated

Calls

Call 1

Inputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))
#s(literal 0 binary64)

Outputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))
#s(literal 0 binary64)

localize54.0ms (1.3%)

Memory

3.9MiB live, 35.3MiB allocated

Localize:

Found 1 expressions of interest:

New	Metric	Score	Program
accuracy	0	#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))

Samples

29.0ms	132×	1	valid
19.0ms	124×	2	valid

Compiler

Compiled 14 to 11 computations (21.4% saved)

Precisions

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

adjust: 11.0ms (46.7% of total)

ival-add: 10.0ms (42.4% of total)

ival-sub: 3.0ms (12.7% of total)

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

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

exact: 0.0ms (0% of total)

series1.0ms (0%)

Memory

1.7MiB live, 1.7MiB allocated

Counts

1 → 36

Calls

Call 1

Inputs
#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())

Outputs
#s(alt 0 (taylor 0 z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())

Calls

9 calls:

Time	Variable		Point	Expression
0.0ms	z	@	0	((- (+ (+ x y) z) (+ x (+ y z))))
0.0ms	z	@	inf	((- (+ (+ x y) z) (+ x (+ y z))))
0.0ms	z	@	-inf	((- (+ (+ x y) z) (+ x (+ y z))))
0.0ms	y	@	inf	((- (+ (+ x y) z) (+ x (+ y z))))
0.0ms	x	@	-inf	((- (+ (+ x y) z) (+ x (+ y z))))

simplify2.0ms (0.1%)

Memory

2.4MiB live, 2.4MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1	36
0	1	36

Stop Event

1×	saturated
1×	saturated

Counts

36 → 36

Calls

Call 1

Inputs
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

Outputs
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)

rewrite183.0ms (4.5%)

Memory

-9.3MiB live, 85.3MiB allocated

Rules

5 110×	`lower-*.f64`
5 110×	`lower-*.f32`
4 104×	`lower-fma.f64`
4 104×	`lower-fma.f32`
3 852×	`lower-/.f64`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	10	13
0	10	13
1	82	3
2	959	3
0	8441	3

Stop Event

1×	iter limit
1×	node limit
1×	saturated

Counts

1 → 1

Calls

Call 1

Inputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))

Outputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))

eval2.0ms (0.1%)

Memory: 2.3MiB live, 2.3MiB allocated
Compiler: Compiled 74 to 5 computations (93.2% saved)

prune3.0ms (0.1%)

Memory

4.0MiB live, 4.0MiB allocated

Pruning

1 alts after pruning (0 fresh and 1 done)

	Pruned	Kept	Total
New	37	0	37
Fresh	0	0	0
Picked	0	1	1
Done	0	0	0
Total	37	1	38

Accuracy

100.0%

Counts

38 → 1

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	100.0%	#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))

Compiler

Compiled 15 to 15 computations (0% saved)

regimes5.0ms (0.1%)

Memory

5.6MiB live, 5.6MiB allocated

Accuracy

Total 0b remaining (0%)

Threshold costs 0b (0%)

Counts

2 → 1

Calls

Call 1

Inputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))

Outputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))

Calls

4 calls:

1.0ms	x
1.0ms	z
1.0ms	y
1.0ms	(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))

Results

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

Compiler

Compiled 14 to 17 computations (-21.4% saved)

simplify38.0ms (0.9%)

Memory

-13.7MiB live, 17.9MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	10	13

Stop Event

1×

saturated

Calls

Call 1

Inputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))

Outputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))

soundness344.0ms (8.5%)

Memory

2.4MiB live, 2.4MiB allocated

Rules

15 312×	`lower-fma.f64`
15 312×	`lower-fma.f32`
5 296×	`lower-/.f32`
5 296×	`lower-/.f64`
2 424×	`lower-*.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	64	456
1	188	456
2	475	456
3	1436	456
4	3501	456
5	4422	456
6	4929	456
7	5060	456
8	5078	456
9	5078	456
0	8926	456

Stop Event

1×	done
1×	iter limit
1×	node limit

Compiler

Compiled 3 to 9 computations (-200% saved)

preprocess97.0ms (2.4%)

Memory

20.5MiB live, 82.0MiB allocated

Remove

(sort x y z)

(negabs x)

(negabs y)

(negabs z)

(abs x)

(abs y)

(abs z)

Compiler

Compiled 54 to 96 computations (-77.8% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

start0.0ms (0%)

analyze0.0ms (0%)

sample1.7s (42.8%)

explain136.0ms (3.4%)

preprocess412.0ms (10.2%)

eval0.0ms (0%)

prune0.0ms (0%)

simplify288.0ms (7.1%)

localize42.0ms (1%)

series5.0ms (0.1%)

simplify195.0ms (4.8%)

rewrite147.0ms (3.7%)

eval32.0ms (0.8%)

prune8.0ms (0.2%)

simplify313.0ms (7.8%)

localize54.0ms (1.3%)

series1.0ms (0%)

simplify2.0ms (0.1%)

rewrite183.0ms (4.5%)

eval2.0ms (0.1%)

prune3.0ms (0.1%)

regimes5.0ms (0.1%)

simplify38.0ms (0.9%)

soundness344.0ms (8.5%)

preprocess97.0ms (2.4%)

end0.0ms (0%)

Profiling