Metrics for Graphics.Rendering.Plot.Render.Plot.Legend:renderLegendInside from plot-0.2.3.4

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated

analyze0.0ms (0%)

Memory

0.6MiB live, 0.6MiB 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.0s (20.8%)

Memory

-37.3MiB live, 1 893.0MiB allocated

Samples

613.0ms	7 614×	0	valid
40.0ms	371×	1	valid
31.0ms	191×	2	valid
17.0ms	80×	3	valid

Precisions

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

ival-add: 230.0ms (85.7% of total)

adjust: 27.0ms (10.1% of total)

ival-true: 7.0ms (2.6% of total)

ival-assert: 4.0ms (1.5% of total)

Bogosity

explain377.0ms (7.7%)

Memory

-26.6MiB live, 258.8MiB allocated

FPErrors

Click to see full error table

Example	Example	Subexpression
-	-	`(+.f64 (+.f64 (+.f64 x y) y) x)`
-	-	`y`
-	-	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)`
-	-	`(+.f64 (+.f64 x y) y)`
-	-	`(+.f64 x y)`
-	-	`z`
-	-	`(+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) 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

92.0ms	476×	0	valid
2.0ms	20×	1	valid
2.0ms	8×	3	valid
1.0ms	8×	2	valid

Compiler

Compiled 91 to 28 computations (69.2% saved)

Precisions

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

ival-add: 12.0ms (80.5% of total)

adjust: 2.0ms (13.4% of total)

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

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

preprocess336.0ms (6.8%)

Memory

20.4MiB live, 60.0MiB allocated

Algorithm

1×	egg-herbie

Rules

2 046×	`unsub-neg`
1 306×	`distribute-neg-in`
1 088×	`associate-+r+`
876×	`sub-neg`
792×	`associate-+l-`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	39	104
1	139	83
2	547	81
3	2356	81
4	4279	81
5	5574	81
6	5954	81
7	6069	81
8	6080	81
9	6080	81
10	6693	81
11	6916	81
12	6934	81
13	6934	81
14	6944	81
15	6954	81
16	6954	81
17	6958	81
18	7718	81
19	7718	81
0	8	11
0	13	11
1	26	9
2	71	9
3	163	9
4	266	9
5	273	9
0	273	7

Stop Event

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

Calls

Call 1

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

Outputs
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)
(fma.f64 #s(literal 3 binary64) x (fma.f64 #s(literal 2 binary64) y z))

Compiler

Compiled 11 to 8 computations (27.3% saved)

eval0.0ms (0%)

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

prune1.0ms (0%)

Memory

1.5MiB live, 1.4MiB allocated

Alt Table

Click to see full alt table

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

Compiler

Compiled 11 to 8 computations (27.3% saved)

simplify7.0ms (0.1%)

Memory

14.1MiB live, 14.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

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

Rules

266×	`lower-+.f32`
256×	`lower-+.f64`
242×	`associate-+r+`
132×	`associate-+l+`
104×	`lower-fma.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	8	38
0	13	38
1	26	32
2	71	32
3	163	32
4	266	32
5	273	32
0	273	28

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

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

Outputs
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)
(fma.f64 #s(literal 3 binary64) x (fma.f64 #s(literal 2 binary64) y z))
(+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z)
(fma.f64 #s(literal 2 binary64) (+.f64 y x) z)
(+.f64 (+.f64 (+.f64 x y) y) x)
(*.f64 #s(literal 2 binary64) (+.f64 y x))
(+.f64 (+.f64 x y) y)
(fma.f64 #s(literal 2 binary64) y x)
(+.f64 x y)
(+.f64 y x)
x
y
z

localize81.0ms (1.6%)

Memory

-30.7MiB live, 48.5MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0	(+.f64 x y)
accuracy	0.03125	(+.f64 (+.f64 (+.f64 x y) y) x)
accuracy	0.03515625	(+.f64 (+.f64 x y) y)
accuracy	0.046875	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)

Samples

72.0ms	238×	0	valid
1.0ms	10×	1	valid
1.0ms	4×	3	valid
1.0ms	4×	2	valid

Compiler

Compiled 40 to 10 computations (75% saved)

Precisions

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

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

adjust: 1.0ms (11.9% of total)

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

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

series8.0ms (0.2%)

Memory

17.3MiB live, 17.3MiB allocated

Counts

5 → 144

Calls

Call 1

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

Outputs
#s(alt (+ (* 2 x) (* 2 y)) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* 2 x) (* 2 y))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* 2 x) (* 2 y))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* 2 x) (* 2 y))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ (* 2 x) (* 2 y))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ z (+ (* 2 x) (* 2 y)))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ z (+ (* 2 x) (* 2 y)))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ z (+ (* 2 x) (* 2 y)))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (* 2 (/ x z)) (* 2 (/ y z))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (* 2 (/ x z)) (* 2 (/ y z))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (* 2 (/ x z)) (* 2 (/ y z))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (* 2 x) (* 2 y)) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (* 2 x) (* 2 y)) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (* 2 x) (* 2 y)) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (+ z (* 2 x)) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* 2 x) (* 2 y))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* 2 x) (* 2 y))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* 2 x) (* 2 y))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 x) (* 2 y)) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 x) (* 2 y)) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 x) (* 2 y)) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ z (* 2 x))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ z (+ (* 2 x) (* 2 y)))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ z (+ (* 2 x) (* 2 y)))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (+ x (+ z (+ (* 2 x) (* 2 y)))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt x (taylor 0 y) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (+ x (* 2 y)) (taylor 0 y) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (+ x (* 2 y)) (taylor 0 y) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (+ x (* 2 y)) (taylor 0 y) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<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 (* 2 y) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 2 (+ (* 2 (/ x y)) (/ z y)))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 2 (+ (* 2 (/ x y)) (/ z y)))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 2 (+ (* 2 (/ x y)) (/ z y)))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* 2 y) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* y (+ 2 (* 2 (/ x y)))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* y (+ 2 (* 2 (/ x y)))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* y (+ 2 (* 2 (/ x y)))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* 2 y) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* 2 y) (taylor inf y) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (* y (+ 2 (/ x y))) (taylor inf y) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (* y (+ 2 (/ x y))) (taylor inf y) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (* y (+ 2 (/ x y))) (taylor inf y) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<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 (* 2 y) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ z (* 2 x)) y)) 2))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ z (* 2 x)) y)) 2))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ z (* 2 x)) y)) 2))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* 2 y) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -2 (/ x y)) 2))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -2 (/ x y)) 2))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -2 (/ x y)) 2))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* 2 y) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* 2 y) (taylor -inf y) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ x y)) 2))) (taylor -inf y) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ x y)) 2))) (taylor -inf y) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ x y)) 2))) (taylor -inf y) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<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 (+ z (* 2 y)) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* 2 x) (* 2 y))) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* 2 x) (* 2 y))) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* 2 x) (* 2 y))) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* 2 y) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 x) (* 2 y)) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 x) (* 2 y)) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 x) (* 2 y)) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (+ z (* 2 y)) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* 2 y) (* 3 x))) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* 2 y) (* 3 x))) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* 2 y) (* 3 x))) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* 2 y) (taylor 0 x) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (+ x (* 2 y)) (taylor 0 x) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (+ x (* 2 y)) (taylor 0 x) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (+ x (* 2 y)) (taylor 0 x) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<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 (* 2 x) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ 2 (+ (* 2 (/ y x)) (/ z x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ 2 (+ (* 2 (/ y x)) (/ z x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ 2 (+ (* 2 (/ y x)) (/ z x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 2 (* 2 (/ y x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 2 (* 2 (/ y x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 2 (* 2 (/ y x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* 3 x) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 3 (+ (* 2 (/ y x)) (/ z x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 3 (+ (* 2 (/ y x)) (/ z x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ 3 (+ (* 2 (/ y x)) (/ z x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* 2 (/ y x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* 2 (/ y x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (* 2 (/ y x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<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 (* 2 x) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 2))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 2))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 2))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) (patch (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) #<representation binary64>) () ())) ())
#s(alt (* 2 x) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -2 (/ y x)) 2))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -2 (/ y x)) 2))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -2 (/ y x)) 2))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 x y) y) x) (patch (+.f64 (+.f64 (+.f64 x y) y) x) #<representation binary64>) () ())) ())
#s(alt (* 3 x) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) (patch (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x) #<representation binary64>) () ())) ())
#s(alt x (taylor -inf x) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -2 (/ y x)) 1))) (taylor -inf x) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -2 (/ y x)) 1))) (taylor -inf x) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -2 (/ y x)) 1))) (taylor -inf x) (#s(alt (+.f64 (+.f64 x y) y) (patch (+.f64 (+.f64 x y) y) #<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>) () ())) ())

Calls

9 calls:

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

simplify186.0ms (3.8%)

Memory

6.0MiB live, 205.7MiB allocated

Algorithm

1×	egg-herbie

Rules

10 710×	`lower-fma.f64`
10 710×	`lower-fma.f32`
2 766×	`lower-*.f64`
2 766×	`lower-*.f32`
1 564×	`times-frac`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	113	764
1	343	762
2	900	762
3	2786	762
4	6677	762
0	8202	658

Stop Event

1×	iter limit
1×	node limit

Counts

144 → 131

Calls

Call 1

Inputs
(+ (* 2 x) (* 2 y))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(+ x (+ (* 2 x) (* 2 y)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
z
(* z (+ 1 (+ (* 2 (/ x z)) (* 2 (/ y z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (* 2 (/ y z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (* 2 (/ y z)))))
z
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
z
(* -1 (* z (- (* -1 (/ (+ (* 2 x) (* 2 y)) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ (* 2 x) (* 2 y)) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ (* 2 x) (* 2 y)) z)) 1)))
z
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(+ z (* 2 x))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(* 2 x)
(+ (* 2 x) (* 2 y))
(+ (* 2 x) (* 2 y))
(+ (* 2 x) (* 2 y))
(+ x (+ z (* 2 x)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
x
(+ x (* 2 y))
(+ x (* 2 y))
(+ x (* 2 y))
x
(+ x y)
(+ x y)
(+ x y)
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (/ z y))))
(* y (+ 2 (+ (* 2 (/ x y)) (/ z y))))
(* y (+ 2 (+ (* 2 (/ x y)) (/ z y))))
(* 2 y)
(* y (+ 2 (* 2 (/ x y))))
(* y (+ 2 (* 2 (/ x y))))
(* y (+ 2 (* 2 (/ x y))))
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* 2 y)
(* y (+ 2 (/ x y)))
(* y (+ 2 (/ x y)))
(* y (+ 2 (/ x y)))
y
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ z (* 2 x)) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ z (* 2 x)) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ z (* 2 x)) y)) 2)))
(* 2 y)
(* -1 (* y (- (* -2 (/ x y)) 2)))
(* -1 (* y (- (* -2 (/ x y)) 2)))
(* -1 (* y (- (* -2 (/ x y)) 2)))
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* 2 y)
(* -1 (* y (- (* -1 (/ x y)) 2)))
(* -1 (* y (- (* -1 (/ x y)) 2)))
(* -1 (* y (- (* -1 (/ x y)) 2)))
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+ z (* 2 y))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(* 2 y)
(+ (* 2 x) (* 2 y))
(+ (* 2 x) (* 2 y))
(+ (* 2 x) (* 2 y))
(+ z (* 2 y))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(* 2 y)
(+ x (* 2 y))
(+ x (* 2 y))
(+ x (* 2 y))
y
(+ x y)
(+ x y)
(+ x y)
(* 2 x)
(* x (+ 2 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 2 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 2 (+ (* 2 (/ y x)) (/ z x))))
(* 2 x)
(* x (+ 2 (* 2 (/ y x))))
(* x (+ 2 (* 2 (/ y x))))
(* x (+ 2 (* 2 (/ y x))))
(* 3 x)
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
x
(* x (+ 1 (* 2 (/ y x))))
(* x (+ 1 (* 2 (/ y x))))
(* x (+ 1 (* 2 (/ y x))))
x
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
(* 2 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 2)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 2)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 2)))
(* 2 x)
(* -1 (* x (- (* -2 (/ y x)) 2)))
(* -1 (* x (- (* -2 (/ y x)) 2)))
(* -1 (* x (- (* -2 (/ y x)) 2)))
(* 3 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
x
(* -1 (* x (- (* -2 (/ y x)) 1)))
(* -1 (* x (- (* -2 (/ y x)) 1)))
(* -1 (* x (- (* -2 (/ y x)) 1)))
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))

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

rewrite355.0ms (7.2%)

Memory

-29.7MiB live, 290.0MiB allocated

Rules

5 184×	`lower-fma.f64`
5 184×	`lower-fma.f32`
4 742×	`lower-*.f64`
4 742×	`lower-*.f32`
4 214×	`lower-/.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	8	35
0	13	35
1	81	29
2	878	29
0	8130	26

Stop Event

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

Counts

5 → 593

Calls

Call 1

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

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval93.0ms (1.9%)

Memory: 44.9MiB live, 232.2MiB allocated
Compiler: Compiled 23 039 to 2 484 computations (89.2% saved)

prune17.0ms (0.4%)

Memory

-13.1MiB live, 62.9MiB allocated

Pruning

7 alts after pruning (7 fresh and 0 done)

	Pruned	Kept	Total
New	717	7	724
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	718	7	725

Accuracy

100.0%

Counts

725 → 7

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	99.9%	(fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x))
	40.9%	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64))) x)
▶	66.0%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
	69.1%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64))))
▶	65.9%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
▶	35.6%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 y #s(literal 2 binary64)))
▶	35.6%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))

Compiler

Compiled 78 to 92 computations (-17.9% saved)

simplify8.0ms (0.2%)

Memory

12.7MiB live, 12.7MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 11 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(fma.f64 y #s(literal 2 binary64) z)
cost-diff	0	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
cost-diff	0	(fma.f64 #s(literal 3 binary64) x z)
cost-diff	0	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
cost-diff	0	(*.f64 y #s(literal 2 binary64))
cost-diff	0	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 y #s(literal 2 binary64)))
cost-diff	0	(*.f64 #s(literal 3 binary64) x)
cost-diff	0	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))
cost-diff	0	(+.f64 z x)
cost-diff	0	(+.f64 y x)
cost-diff	0	(fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x))

Rules

266×	`lower-+.f32`
262×	`lower-+.f64`
244×	`associate-+r+`
118×	`associate-+l+`
104×	`lower-fma.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	21	104
0	29	104
1	55	92
2	107	92
3	209	92
4	274	92
5	278	92
0	278	87

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x))
#s(literal 2 binary64)
(+.f64 y x)
y
x
(+.f64 z x)
z
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))
(*.f64 #s(literal 3 binary64) x)
#s(literal 3 binary64)
x
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 y #s(literal 2 binary64)))
(*.f64 y #s(literal 2 binary64))
y
#s(literal 2 binary64)
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
(fma.f64 #s(literal 3 binary64) x z)
#s(literal 3 binary64)
x
z
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
(fma.f64 y #s(literal 2 binary64) z)
y
#s(literal 2 binary64)
z

Outputs
(fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x))
(fma.f64 #s(literal 3 binary64) x (fma.f64 y #s(literal 2 binary64) z))
#s(literal 2 binary64)
(+.f64 y x)
(+.f64 x y)
y
x
(+.f64 z x)
z
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))
(*.f64 #s(literal 3 binary64) x)
#s(literal 3 binary64)
x
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 y #s(literal 2 binary64)))
(*.f64 y #s(literal 2 binary64))
y
#s(literal 2 binary64)
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
(fma.f64 #s(literal 3 binary64) x z)
#s(literal 3 binary64)
x
z
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
(fma.f64 y #s(literal 2 binary64) z)
y
#s(literal 2 binary64)
z

localize49.0ms (1%)

Memory

2.8MiB live, 87.4MiB allocated

Localize:

Found 11 expressions of interest:

New	Metric	Score
accuracy	0	(fma.f64 y #s(literal 2 binary64) z)
accuracy	21.741796533681182	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
accuracy	0	(fma.f64 #s(literal 3 binary64) x z)
accuracy	21.82072877427075	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
accuracy	0	(*.f64 y #s(literal 2 binary64))
accuracy	41.21779452736478	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 y #s(literal 2 binary64)))
accuracy	0	(*.f64 #s(literal 3 binary64) x)
accuracy	41.24558169347854	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))
accuracy	0	(+.f64 z x)
accuracy	0	(+.f64 y x)
accuracy	0.04296875	(fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x))

Samples

29.0ms	233×	0	valid
4.0ms	6×	3	valid
4.0ms	8×	2	valid
2.0ms	9×	1	valid

Compiler

Compiled 91 to 20 computations (78% saved)

Precisions

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

ival-add: 12.0ms (52.4% of total)

ival-mult: 8.0ms (34.9% of total)

adjust: 2.0ms (8.7% of total)

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

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

exact: 0.0ms (0% of total)

series16.0ms (0.3%)

Memory

-0.6MiB live, 38.7MiB allocated

Counts

11 → 300

Calls

Call 1

Inputs
#s(alt (fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x)) (patch (fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x)) #<representation binary64>) () ())
#s(alt (+.f64 y x) (patch (+.f64 y x) #<representation binary64>) () ())
#s(alt (+.f64 z x) (patch (+.f64 z x) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (.f64 #s(literal 3 binary64) x)) (patch #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (.f64 #s(literal 3 binary64) x)) #<representation binary64>) () ())
#s(alt (.f64 #s(literal 3 binary64) x) (patch (.f64 #s(literal 3 binary64) x) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (.f64 y #s(literal 2 binary64))) (patch #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (.f64 y #s(literal 2 binary64))) #<representation binary64>) () ())
#s(alt (.f64 y #s(literal 2 binary64)) (patch (.f64 y #s(literal 2 binary64)) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z)) (patch #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z)) #<representation binary64>) () ())
#s(alt (fma.f64 #s(literal 3 binary64) x z) (patch (fma.f64 #s(literal 3 binary64) x z) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z)) #<representation binary64>) () ())
#s(alt (fma.f64 y #s(literal 2 binary64) z) (patch (fma.f64 y #s(literal 2 binary64) z) #<representation binary64>) () ())

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

Calls

9 calls:

Time	Variable		Point	Expression
2.0ms	z	@	-inf	((+ (* 2 (+ y x)) (+ z x)) (+ y x) (+ z x) (+ (+ (+ (+ (+ x y) y) x) z) x) (* 3 x) (+ (+ (+ (+ (+ x y) y) x) z) x) (* y 2) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* 3 x) z) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* y 2) z))
1.0ms	y	@	inf	((+ (* 2 (+ y x)) (+ z x)) (+ y x) (+ z x) (+ (+ (+ (+ (+ x y) y) x) z) x) (* 3 x) (+ (+ (+ (+ (+ x y) y) x) z) x) (* y 2) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* 3 x) z) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* y 2) z))
1.0ms	x	@	inf	((+ (* 2 (+ y x)) (+ z x)) (+ y x) (+ z x) (+ (+ (+ (+ (+ x y) y) x) z) x) (* 3 x) (+ (+ (+ (+ (+ x y) y) x) z) x) (* y 2) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* 3 x) z) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* y 2) z))
1.0ms	x	@	-inf	((+ (* 2 (+ y x)) (+ z x)) (+ y x) (+ z x) (+ (+ (+ (+ (+ x y) y) x) z) x) (* 3 x) (+ (+ (+ (+ (+ x y) y) x) z) x) (* y 2) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* 3 x) z) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* y 2) z))
1.0ms	y	@	-inf	((+ (* 2 (+ y x)) (+ z x)) (+ y x) (+ z x) (+ (+ (+ (+ (+ x y) y) x) z) x) (* 3 x) (+ (+ (+ (+ (+ x y) y) x) z) x) (* y 2) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* 3 x) z) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* y 2) z))

simplify129.0ms (2.6%)

Memory

-10.8MiB live, 161.7MiB allocated

Algorithm

1×	egg-herbie

Rules

9 888×	`lower-fma.f64`
9 888×	`lower-fma.f32`
2 778×	`lower-*.f64`
2 778×	`lower-*.f32`
1 838×	`unsub-neg`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	122	1766
1	361	1766
2	896	1766
3	2758	1766
4	5764	1766
0	8140	1445

Stop Event

1×	iter limit
1×	node limit

Counts

300 → 272

Calls

Call 1

Inputs
(+ x (* 2 (+ x y)))
(+ x (+ z (* 2 (+ x y))))
(+ x (+ z (* 2 (+ x y))))
(+ x (+ z (* 2 (+ x y))))
x
(+ x z)
(+ x z)
(+ x z)
(+ x (+ (* 2 x) (* 2 y)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ (* 2 x) (* 2 y)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ (* 2 x) (* 2 y)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(* 3 x)
(+ z (* 3 x))
(+ z (* 3 x))
(+ z (* 3 x))
(+ x (+ (* 2 x) (* 2 y)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(* 2 y)
(+ z (* 2 y))
(+ z (* 2 y))
(+ z (* 2 y))
z
(* z (+ 1 (+ (* 2 (/ (+ x y) z)) (/ x z))))
(* z (+ 1 (+ (* 2 (/ (+ x y) z)) (/ x z))))
(* z (+ 1 (+ (* 2 (/ (+ x y) z)) (/ x z))))
z
(* z (+ 1 (/ x z)))
(* z (+ 1 (/ x z)))
(* z (+ 1 (/ x z)))
z
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
z
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
z
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
z
(* z (+ 1 (* 3 (/ x z))))
(* z (+ 1 (* 3 (/ x z))))
(* z (+ 1 (* 3 (/ x z))))
z
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
z
(* z (+ 1 (* 2 (/ y z))))
(* z (+ 1 (* 2 (/ y z))))
(* z (+ 1 (* 2 (/ y z))))
z
(* -1 (* z (- (* -1 (/ (+ x (* 2 (+ x y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (* 2 (+ x y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (* 2 (+ x y))) z)) 1)))
z
(* -1 (* z (- (* -1 (/ x z)) 1)))
(* -1 (* z (- (* -1 (/ x z)) 1)))
(* -1 (* z (- (* -1 (/ x z)) 1)))
z
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
z
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
z
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
z
(* -1 (* z (- (* -3 (/ x z)) 1)))
(* -1 (* z (- (* -3 (/ x z)) 1)))
(* -1 (* z (- (* -3 (/ x z)) 1)))
z
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
z
(* -1 (* z (- (* -2 (/ y z)) 1)))
(* -1 (* z (- (* -2 (/ y z)) 1)))
(* -1 (* z (- (* -2 (/ y z)) 1)))
(+ x (+ z (* 2 x)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
x
(+ x y)
(+ x y)
(+ x y)
(+ x (+ z (* 2 x)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (* 2 x)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(+ x (+ z (* 2 x)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (* 2 x)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
z
(+ z (* 2 y))
(+ z (* 2 y))
(+ z (* 2 y))
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
y
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* 2 y)
(* y (+ 2 (/ z y)))
(* y (+ 2 (/ z y)))
(* y (+ 2 (/ z y)))
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* 2 y)
(* -1 (* y (- (* -1 (/ z y)) 2)))
(* -1 (* y (- (* -1 (/ z y)) 2)))
(* -1 (* y (- (* -1 (/ z y)) 2)))
(+ z (* 2 y))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
y
(+ x y)
(+ x y)
(+ x y)
z
(+ x z)
(+ x z)
(+ x z)
(+ z (* 2 y))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(* 3 x)
(* 3 x)
(* 3 x)
(* 3 x)
(+ z (* 2 y))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (* 2 y))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
z
(+ z (* 3 x))
(+ z (* 3 x))
(+ z (* 3 x))
(+ z (* 2 y))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(* 3 x)
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
x
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
x
(* x (+ 1 (/ z x)))
(* x (+ 1 (/ z x)))
(* x (+ 1 (/ z x)))
(* 3 x)
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* 3 x)
(* 3 x)
(* 3 x)
(* 3 x)
(* 3 x)
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* 3 x)
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* 3 x)
(* x (+ 3 (/ z x)))
(* x (+ 3 (/ z x)))
(* x (+ 3 (/ z x)))
(* 3 x)
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* 3 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
x
(* -1 (* x (- (* -1 (/ z x)) 1)))
(* -1 (* x (- (* -1 (/ z x)) 1)))
(* -1 (* x (- (* -1 (/ z x)) 1)))
(* 3 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* 3 x)
(* 3 x)
(* 3 x)
(* 3 x)
(* 3 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* 3 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* 3 x)
(* -1 (* x (- (* -1 (/ z x)) 3)))
(* -1 (* x (- (* -1 (/ z x)) 3)))
(* -1 (* x (- (* -1 (/ z x)) 3)))
(* 3 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))

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

rewrite150.0ms (3.1%)

Memory

-27.7MiB live, 253.3MiB allocated

Rules

4 856×	`lower-fma.f32`
4 850×	`lower-fma.f64`
4 494×	`lower-/.f64`
4 494×	`lower-/.f32`
3 082×	`lower-*.f32`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	21	90
0	29	90
1	158	78
2	1770	78
0	8225	78

Stop Event

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

Counts

11 → 205

Calls

Call 1

Inputs
(fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x))
(+.f64 y x)
(+.f64 z x)
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))
(*.f64 #s(literal 3 binary64) x)
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 y #s(literal 2 binary64)))
(*.f64 y #s(literal 2 binary64))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
(fma.f64 #s(literal 3 binary64) x z)
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
(fma.f64 y #s(literal 2 binary64) z)

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval54.0ms (1.1%)

Memory: 13.4MiB live, 133.6MiB allocated
Compiler: Compiled 6 890 to 714 computations (89.6% saved)

prune19.0ms (0.4%)

Memory

14.3MiB live, 51.7MiB allocated

Pruning

8 alts after pruning (4 fresh and 4 done)

	Pruned	Kept	Total
New	475	2	477
Fresh	0	2	2
Picked	1	4	5
Done	0	0	0
Total	476	8	484

Accuracy

100.0%

Counts

484 → 8

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	99.9%	(fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x))
▶	40.9%	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64))) x)
▶	69.0%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 (+.f64 y x) #s(literal 2 binary64) x))
✓	66.0%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
▶	69.1%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64))))
✓	65.9%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
▶	35.6%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
✓	35.6%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))

Compiler

Compiled 46 to 52 computations (-13% saved)

simplify10.0ms (0.2%)

Memory

-27.0MiB live, 11.6MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 11 expressions of interest:

New	Metric	Score
cost-diff	0	(*.f64 y #s(literal 2 binary64))
cost-diff	0	#s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64)))
cost-diff	0	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64))) x)
cost-diff	0	(+.f64 y x)
cost-diff	0	(fma.f64 (+.f64 y x) #s(literal 2 binary64) x)
cost-diff	0	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 (+.f64 y x) #s(literal 2 binary64) x))
cost-diff	0	(*.f64 y #s(literal 2 binary64))
cost-diff	0	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64))))
cost-diff	128	(fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64)))
cost-diff	-128	(+.f64 y y)
cost-diff	0	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))

Rules

278×	`associate-+r+`
270×	`lower-+.f32`
264×	`lower-+.f64`
136×	`associate-+l+`
104×	`lower-fma.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	20	114
0	28	114
1	49	101
2	103	101
3	230	101
4	311	101
5	317	101
0	317	96

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
(+.f64 y y)
y
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64))))
(fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64)))
#s(literal 3 binary64)
x
(*.f64 y #s(literal 2 binary64))
y
#s(literal 2 binary64)
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 (+.f64 y x) #s(literal 2 binary64) x))
(fma.f64 (+.f64 y x) #s(literal 2 binary64) x)
(+.f64 y x)
y
x
#s(literal 2 binary64)
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64))) x)
#s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64)))
(*.f64 y #s(literal 2 binary64))
y
#s(literal 2 binary64)
x

Outputs
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 2 binary64) y))
(+.f64 y y)
(*.f64 #s(literal 2 binary64) y)
y
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64))))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 2 binary64) (+.f64 y x) x))
(fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64)))
(fma.f64 #s(literal 2 binary64) (+.f64 y x) x)
#s(literal 3 binary64)
x
(*.f64 y #s(literal 2 binary64))
(*.f64 #s(literal 2 binary64) y)
y
#s(literal 2 binary64)
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 (+.f64 y x) #s(literal 2 binary64) x))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 2 binary64) (+.f64 y x) x))
(fma.f64 (+.f64 y x) #s(literal 2 binary64) x)
(fma.f64 #s(literal 2 binary64) (+.f64 y x) x)
(+.f64 y x)
y
x
#s(literal 2 binary64)
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64))) x)
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 #s(literal 2 binary64) y)) x)
#s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64)))
#s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 #s(literal 2 binary64) y))
(*.f64 y #s(literal 2 binary64))
(*.f64 #s(literal 2 binary64) y)
y
#s(literal 2 binary64)
x

localize66.0ms (1.4%)

Memory

1.7MiB live, 122.7MiB allocated

Localize:

Found 11 expressions of interest:

New	Metric	Score
accuracy	0	(*.f64 y #s(literal 2 binary64))
accuracy	0.046875	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64))) x)
accuracy	41.207721612894964	#s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64)))
accuracy	0	(+.f64 y x)
accuracy	0.08203125	(fma.f64 (+.f64 y x) #s(literal 2 binary64) x)
accuracy	19.792469708110467	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 (+.f64 y x) #s(literal 2 binary64) x))
accuracy	0	(fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64)))
accuracy	0	(*.f64 y #s(literal 2 binary64))
accuracy	19.792469708110467	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64))))
accuracy	0	(+.f64 y y)
accuracy	41.21779452736478	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))

Samples

28.0ms	232×	0	valid
4.0ms	10×	1	valid
4.0ms	8×	3	valid
2.0ms	6×	2	valid

Compiler

Compiled 92 to 19 computations (79.3% saved)

Precisions

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

ival-add: 15.0ms (61.7% of total)

ival-mult: 5.0ms (20.6% of total)

adjust: 4.0ms (16.5% of total)

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

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

exact: 0.0ms (0% of total)

series13.0ms (0.3%)

Memory

24.1MiB live, 24.1MiB allocated

Counts

10 → 276

Calls

Call 1

Inputs
#s(alt #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y)) (patch #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y)) #<representation binary64>) () ())
#s(alt (+.f64 y y) (patch (+.f64 y y) #<representation binary64>) () ())
#s(alt (fma.f64 #s(literal 3 binary64) x (.f64 y #s(literal 2 binary64))) (patch (fma.f64 #s(literal 3 binary64) x (.f64 y #s(literal 2 binary64))) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (.f64 y #s(literal 2 binary64)))) (patch #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (.f64 y #s(literal 2 binary64)))) #<representation binary64>) () ())
#s(alt (.f64 y #s(literal 2 binary64)) (patch (.f64 y #s(literal 2 binary64)) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 (+.f64 y x) #s(literal 2 binary64) x)) (patch #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 (+.f64 y x) #s(literal 2 binary64) x)) #<representation binary64>) () ())
#s(alt (fma.f64 (+.f64 y x) #s(literal 2 binary64) x) (patch (fma.f64 (+.f64 y x) #s(literal 2 binary64) x) #<representation binary64>) () ())
#s(alt (+.f64 y x) (patch (+.f64 y x) #<representation binary64>) () ())
#s(alt (+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (.f64 y #s(literal 2 binary64))) x) (patch (+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (.f64 y #s(literal 2 binary64))) x) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ x y) y) x) z) (.f64 y #s(literal 2 binary64))) (patch #s(approx (+ (+ (+ (+ x y) y) x) z) (.f64 y #s(literal 2 binary64))) #<representation binary64>) () ())

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

Calls

9 calls:

Time	Variable		Point	Expression
1.0ms	y	@	inf	((+ (+ (+ (+ (+ x y) y) x) z) x) (+ y y) (+ (* 3 x) (* y 2)) (+ (+ (+ (+ (+ x y) y) x) z) x) (* y 2) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* (+ y x) 2) x) (+ y x) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (+ (+ (+ x y) y) x) z))
1.0ms	y	@	-inf	((+ (+ (+ (+ (+ x y) y) x) z) x) (+ y y) (+ (* 3 x) (* y 2)) (+ (+ (+ (+ (+ x y) y) x) z) x) (* y 2) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* (+ y x) 2) x) (+ y x) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (+ (+ (+ x y) y) x) z))
1.0ms	x	@	inf	((+ (+ (+ (+ (+ x y) y) x) z) x) (+ y y) (+ (* 3 x) (* y 2)) (+ (+ (+ (+ (+ x y) y) x) z) x) (* y 2) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* (+ y x) 2) x) (+ y x) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (+ (+ (+ x y) y) x) z))
1.0ms	x	@	-inf	((+ (+ (+ (+ (+ x y) y) x) z) x) (+ y y) (+ (* 3 x) (* y 2)) (+ (+ (+ (+ (+ x y) y) x) z) x) (* y 2) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* (+ y x) 2) x) (+ y x) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (+ (+ (+ x y) y) x) z))
1.0ms	y	@	0	((+ (+ (+ (+ (+ x y) y) x) z) x) (+ y y) (+ (* 3 x) (* y 2)) (+ (+ (+ (+ (+ x y) y) x) z) x) (* y 2) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (* (+ y x) 2) x) (+ y x) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (+ (+ (+ x y) y) x) z))

simplify136.0ms (2.8%)

Memory

8.0MiB live, 163.6MiB allocated

Algorithm

1×	egg-herbie

Rules

12 636×	`lower-fma.f64`
12 636×	`lower-fma.f32`
3 300×	`lower-*.f64`
3 300×	`lower-*.f32`
1 474×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	113	1742
1	345	1734
2	926	1734
3	2990	1734
4	6703	1734
0	8234	1441

Stop Event

1×	iter limit
1×	node limit

Counts

276 → 260

Calls

Call 1

Inputs
(+ x (+ (* 2 x) (* 2 y)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ (* 2 x) (* 2 y)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ (* 2 x) (* 2 y)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ (* 2 x) (* 2 y)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ (* 2 x) (* 2 y))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
z
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
z
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
z
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
z
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
z
(* z (+ 1 (+ (* 2 (/ x z)) (* 2 (/ y z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (* 2 (/ y z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (* 2 (/ y z)))))
z
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
z
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
z
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
z
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
z
(* -1 (* z (- (* -1 (/ (+ (* 2 x) (* 2 y)) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ (* 2 x) (* 2 y)) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ (* 2 x) (* 2 y)) z)) 1)))
(+ x (+ z (* 2 x)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* 3 x)
(+ (* 2 y) (* 3 x))
(+ (* 2 y) (* 3 x))
(+ (* 2 y) (* 3 x))
(+ x (+ z (* 2 x)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(+ x (+ z (* 2 x)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (* 2 x))
(+ x (+ (* 2 x) (* 2 y)))
(+ x (+ (* 2 x) (* 2 y)))
(+ x (+ (* 2 x) (* 2 y)))
x
(+ x y)
(+ x y)
(+ x y)
(+ x (+ z (* 2 x)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ z (* 2 x))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* y (+ 2 (* 3 (/ x y))))
(* y (+ 2 (* 3 (/ x y))))
(* y (+ 2 (* 3 (/ x y))))
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (/ x y))))
(* y (+ 2 (+ (* 2 (/ x y)) (/ x y))))
(* y (+ 2 (+ (* 2 (/ x y)) (/ x y))))
y
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (/ z y))))
(* y (+ 2 (+ (* 2 (/ x y)) (/ z y))))
(* y (+ 2 (+ (* 2 (/ x y)) (/ z y))))
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* -1 (* y (- (* -3 (/ x y)) 2)))
(* -1 (* y (- (* -3 (/ x y)) 2)))
(* -1 (* y (- (* -3 (/ x y)) 2)))
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ x (* 2 x)) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (* 2 x)) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (* 2 x)) y)) 2)))
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ z (* 2 x)) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ z (* 2 x)) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ z (* 2 x)) y)) 2)))
(+ z (* 2 y))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(* 2 y)
(+ (* 2 y) (* 3 x))
(+ (* 2 y) (* 3 x))
(+ (* 2 y) (* 3 x))
(+ z (* 2 y))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (* 2 y))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(* 2 y)
(+ (* 2 y) (* 3 x))
(+ (* 2 y) (* 3 x))
(+ (* 2 y) (* 3 x))
y
(+ x y)
(+ x y)
(+ x y)
(+ z (* 2 y))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (* 2 y))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(* 3 x)
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* 3 x)
(* x (+ 3 (* 2 (/ y x))))
(* x (+ 3 (* 2 (/ y x))))
(* x (+ 3 (* 2 (/ y x))))
(* 3 x)
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* 3 x)
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* 3 x)
(* x (+ 3 (* 2 (/ y x))))
(* x (+ 3 (* 2 (/ y x))))
(* x (+ 3 (* 2 (/ y x))))
x
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
(* 3 x)
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* 2 x)
(* x (+ 2 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 2 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 2 (+ (* 2 (/ y x)) (/ z x))))
(* 3 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* 3 x)
(* -1 (* x (- (* -2 (/ y x)) 3)))
(* -1 (* x (- (* -2 (/ y x)) 3)))
(* -1 (* x (- (* -2 (/ y x)) 3)))
(* 3 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* 3 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* 3 x)
(* -1 (* x (- (* -2 (/ y x)) 3)))
(* -1 (* x (- (* -2 (/ y x)) 3)))
(* -1 (* x (- (* -2 (/ y x)) 3)))
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* 3 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* 2 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 2)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 2)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 2)))

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

rewrite165.0ms (3.4%)

Memory

-0.1MiB live, 277.4MiB allocated

Rules

5 592×	`lower-*.f32`
5 590×	`lower-*.f64`
4 184×	`lower-fma.f32`
4 180×	`lower-fma.f64`
4 000×	`lower-/.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	20	100
0	28	100
1	149	87
2	1669	87
0	8249	85

Stop Event

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

Counts

10 → 343

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
(+.f64 y y)
(fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64)))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64))))
(*.f64 y #s(literal 2 binary64))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 (+.f64 y x) #s(literal 2 binary64) x))
(fma.f64 (+.f64 y x) #s(literal 2 binary64) x)
(+.f64 y x)
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64))) x)
#s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64)))

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval100.0ms (2%)

Memory: -25.0MiB live, 167.6MiB allocated
Compiler: Compiled 8 200 to 1 178 computations (85.6% saved)

prune14.0ms (0.3%)

Memory

7.0MiB live, 46.0MiB allocated

Pruning

7 alts after pruning (2 fresh and 5 done)

	Pruned	Kept	Total
New	708	2	710
Fresh	0	0	0
Picked	3	1	4
Done	0	4	4
Total	711	7	718

Accuracy

100.0%

Counts

718 → 7

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	99.9%	(fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x))
▶	40.9%	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x)
✓	66.0%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
▶	69.1%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y)))
✓	65.9%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
✓	35.6%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
✓	35.6%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))

Compiler

Compiled 39 to 43 computations (-10.3% saved)

simplify8.0ms (0.2%)

Memory

9.1MiB live, 9.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 6 expressions of interest:

New	Metric	Score
cost-diff	-128	(+.f64 y y)
cost-diff	0	#s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y))
cost-diff	0	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x)
cost-diff	-128	(+.f64 y y)
cost-diff	0	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y)))
cost-diff	128	(fma.f64 #s(literal 3 binary64) x (+.f64 y y))

Rules

270×	`lower-+.f32`
266×	`lower-+.f64`
264×	`associate-+r+`
130×	`associate-+l+`
104×	`lower-fma.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	14	63
0	18	63
1	37	57
2	83	57
3	185	56
4	287	56
5	291	56
0	291	53

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y)))
(fma.f64 #s(literal 3 binary64) x (+.f64 y y))
#s(literal 3 binary64)
x
(+.f64 y y)
y
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x)
#s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y))
(+.f64 y y)
y
x

Outputs
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y)))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 2 binary64) (+.f64 y x) x))
(fma.f64 #s(literal 3 binary64) x (+.f64 y y))
(fma.f64 #s(literal 2 binary64) (+.f64 y x) x)
#s(literal 3 binary64)
x
(+.f64 y y)
(*.f64 #s(literal 2 binary64) y)
y
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x)
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 #s(literal 2 binary64) y)) x)
#s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y))
#s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 #s(literal 2 binary64) y))
(+.f64 y y)
(*.f64 #s(literal 2 binary64) y)
y
x

localize32.0ms (0.6%)

Memory

11.6MiB live, 50.0MiB allocated

Localize:

Found 6 expressions of interest:

New	Metric	Score
accuracy	0	(+.f64 y y)
accuracy	0.046875	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x)
accuracy	41.207721612894964	#s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y))
accuracy	0	(fma.f64 #s(literal 3 binary64) x (+.f64 y y))
accuracy	0	(+.f64 y y)
accuracy	19.792469708110467	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y)))

Samples

19.0ms	232×	0	valid
2.0ms	8×	3	valid
2.0ms	10×	1	valid
1.0ms	6×	2	valid

Compiler

Compiled 51 to 14 computations (72.5% saved)

Precisions

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

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

adjust: 2.0ms (15.7% of total)

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

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

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

exact: 0.0ms (0% of total)

series7.0ms (0.1%)

Memory

8.7MiB live, 8.7MiB allocated

Counts

5 → 144

Calls

Call 1

Inputs
#s(alt (fma.f64 #s(literal 3 binary64) x (+.f64 y y)) (patch (fma.f64 #s(literal 3 binary64) x (+.f64 y y)) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y))) (patch #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y))) #<representation binary64>) () ())
#s(alt (+.f64 y y) (patch (+.f64 y y) #<representation binary64>) () ())
#s(alt (+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x) (patch (+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) (patch #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) #<representation binary64>) () ())

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

Calls

9 calls:

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

simplify122.0ms (2.5%)

Memory

-14.5MiB live, 101.7MiB allocated

Algorithm

1×	egg-herbie

Rules

10 676×	`lower-fma.f64`
10 676×	`lower-fma.f32`
2 686×	`lower-*.f64`
2 686×	`lower-*.f32`
1 320×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	91	950
1	271	946
2	738	946
3	2061	946
4	4526	946
0	8380	785

Stop Event

1×	iter limit
1×	node limit

Counts

144 → 138

Calls

Call 1

Inputs
(+ x (+ (* 2 x) (* 2 y)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ (* 2 x) (* 2 y)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ (* 2 x) (* 2 y))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
z
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
z
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (+ (* 2 (/ y z)) (/ x z)))))
z
(* z (+ 1 (+ (* 2 (/ x z)) (* 2 (/ y z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (* 2 (/ y z)))))
(* z (+ 1 (+ (* 2 (/ x z)) (* 2 (/ y z)))))
z
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
z
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x (+ (* 2 x) (* 2 y))) z)) 1)))
z
(* -1 (* z (- (* -1 (/ (+ (* 2 x) (* 2 y)) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ (* 2 x) (* 2 y)) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ (* 2 x) (* 2 y)) z)) 1)))
(* 3 x)
(+ (* 2 y) (* 3 x))
(+ (* 2 y) (* 3 x))
(+ (* 2 y) (* 3 x))
(+ x (+ z (* 2 x)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(+ x (+ z (* 2 x)))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ x (+ z (+ (* 2 x) (* 2 y))))
(+ z (* 2 x))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(* 2 y)
(* y (+ 2 (* 3 (/ x y))))
(* y (+ 2 (* 3 (/ x y))))
(* y (+ 2 (* 3 (/ x y))))
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* y (+ 2 (+ (* 2 (/ x y)) (+ (/ x y) (/ z y)))))
(* 2 y)
(* y (+ 2 (+ (* 2 (/ x y)) (/ z y))))
(* y (+ 2 (+ (* 2 (/ x y)) (/ z y))))
(* y (+ 2 (+ (* 2 (/ x y)) (/ z y))))
(* 2 y)
(* -1 (* y (- (* -3 (/ x y)) 2)))
(* -1 (* y (- (* -3 (/ x y)) 2)))
(* -1 (* y (- (* -3 (/ x y)) 2)))
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ x (+ z (* 2 x))) y)) 2)))
(* 2 y)
(* -1 (* y (- (* -1 (/ (+ z (* 2 x)) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ z (* 2 x)) y)) 2)))
(* -1 (* y (- (* -1 (/ (+ z (* 2 x)) y)) 2)))
(* 2 y)
(+ (* 2 y) (* 3 x))
(+ (* 2 y) (* 3 x))
(+ (* 2 y) (* 3 x))
(+ z (* 2 y))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (* 2 y))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (+ (* 2 y) (* 3 x)))
(+ z (* 2 y))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(+ z (+ (* 2 x) (* 2 y)))
(* 3 x)
(* x (+ 3 (* 2 (/ y x))))
(* x (+ 3 (* 2 (/ y x))))
(* x (+ 3 (* 2 (/ y x))))
(* 3 x)
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* 3 x)
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 3 (+ (* 2 (/ y x)) (/ z x))))
(* 2 x)
(* x (+ 2 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 2 (+ (* 2 (/ y x)) (/ z x))))
(* x (+ 2 (+ (* 2 (/ y x)) (/ z x))))
(* 3 x)
(* -1 (* x (- (* -2 (/ y x)) 3)))
(* -1 (* x (- (* -2 (/ y x)) 3)))
(* -1 (* x (- (* -2 (/ y x)) 3)))
(* 3 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* 3 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 3)))
(* 2 x)
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 2)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 2)))
(* -1 (* x (- (* -1 (/ (+ z (* 2 y)) x)) 2)))

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

rewrite175.0ms (3.6%)

Memory

12.5MiB live, 165.5MiB allocated

Rules

5 222×	`lower-fma.f32`
5 220×	`lower-fma.f64`
5 108×	`lower-*.f64`
5 108×	`lower-*.f32`
4 010×	`lower-/.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	14	55
0	18	55
1	119	49
2	1288	49
0	8432	46

Stop Event

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

Counts

5 → 173

Calls

Call 1

Inputs
(fma.f64 #s(literal 3 binary64) x (+.f64 y y))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y)))
(+.f64 y y)
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x)
#s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y))

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval49.0ms (1%)

Memory: -18.6MiB live, 69.5MiB allocated
Compiler: Compiled 5 121 to 814 computations (84.1% saved)

prune10.0ms (0.2%)

Memory

27.8MiB live, 27.8MiB allocated

Pruning

7 alts after pruning (0 fresh and 7 done)

	Pruned	Kept	Total
New	408	0	408
Fresh	0	0	0
Picked	0	2	2
Done	0	5	5
Total	408	7	415

Accuracy

100.0%

Counts

415 → 7

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	99.9%	(fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x))
✓	40.9%	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x)
✓	66.0%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
✓	69.1%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y)))
✓	65.9%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
✓	35.6%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
✓	35.6%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))

Compiler

Compiled 113 to 76 computations (32.7% saved)

regimes21.0ms (0.4%)

Memory

-10.7MiB live, 27.6MiB allocated

Counts

12 → 1

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 y #s(literal 2 binary64)))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x)
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64))) x)
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y)))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 (+.f64 y x) #s(literal 2 binary64) x))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64))))
(fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x))
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)

Outputs
(fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x))

Calls

4 calls:

7.0ms	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)
4.0ms	x
4.0ms	z
4.0ms	y

Results

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

Compiler

Compiled 14 to 17 computations (-21.4% saved)

regimes20.0ms (0.4%)

Memory

-11.6MiB live, 25.8MiB allocated

Counts

10 → 3

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 y #s(literal 2 binary64)))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x)
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64))) x)
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y)))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 (+.f64 y x) #s(literal 2 binary64) x))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64))))

Outputs

#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))

#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y)))

#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))

Calls

4 calls:

8.0ms	y
4.0ms	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)
4.0ms	z
4.0ms	x

Results

Accuracy	Segments	Branch
90.3%	3	`x`
89.3%	4	`y`
91.1%	3	`z`
78.8%	3	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)`

Compiler

Compiled 14 to 17 computations (-21.4% saved)

regimes6.0ms (0.1%)

Memory

8.4MiB live, 8.4MiB allocated

Counts

7 → 3

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 y #s(literal 2 binary64)))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x)
(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64))) x)

Outputs

#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))

#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))

#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))

Calls

2 calls:

3.0ms	z
3.0ms	x

Results

Accuracy	Segments	Branch
90.3%	3	`x`
75.1%	5	`z`

Compiler

Compiled 2 to 6 computations (-200% saved)

regimes5.0ms (0.1%)

Memory

6.6MiB live, 6.6MiB allocated

Counts

4 → 3

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 y #s(literal 2 binary64)))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))

Outputs
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))

Calls

2 calls:

2.0ms	y
2.0ms	x

Results

Accuracy	Segments	Branch
80.8%	3	`y`
75.6%	5	`x`

Compiler

Compiled 2 to 6 computations (-200% saved)

regimes12.0ms (0.2%)

Memory

-18.9MiB live, 18.5MiB allocated

Counts

3 → 3

Calls

Call 1

Inputs

#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))

#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))

#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 y #s(literal 2 binary64)))

Outputs

#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))

#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))

#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))

Calls

4 calls:

6.0ms	x
2.0ms	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)
2.0ms	y
2.0ms	z

Results

Accuracy	Segments	Branch
42.4%	4	`z`
59.9%	3	`x`
44.5%	4	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)`
57.0%	3	`y`

Compiler

Compiled 14 to 17 computations (-21.4% saved)

regimes6.0ms (0.1%)

Memory

9.8MiB live, 9.8MiB allocated

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

1 → 1

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))

Outputs
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))

Calls

4 calls:

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

Results

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

Compiler

Compiled 14 to 17 computations (-21.4% saved)

bsearch49.0ms (1%)

Memory

-20.9MiB live, 110.6MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
27.0ms	1.4221968237157666e+71	2.4172446486942106e+83
18.0ms	-1.6882916566165448e+83	-2.5908099341704903e+79

Samples

13.0ms	264×	0	valid
2.0ms	19×	1	valid
1.0ms	5×	2	valid

Compiler

Compiled 230 to 284 computations (-23.5% saved)

Precisions

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

ival-add: 8.0ms (87.8% of total)

adjust: 1.0ms (11% of total)

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

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

bsearch19.0ms (0.4%)

Memory

16.2MiB live, 55.6MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
9.0ms	9.266609239210886e-47	7.365652341515222e-46
7.0ms	-2.8486521699381002e+69	-7.591119707449266e+68

Samples

9.0ms	165×	0	valid
1.0ms	8×	1	valid
1.0ms	3×	2	valid

Compiler

Compiled 124 to 168 computations (-35.5% saved)

Precisions

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

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

adjust: 0.0ms (0% of total)

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

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

bsearch29.0ms (0.6%)

Memory

-6.3MiB live, 76.3MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
11.0ms	1.2209668306750264e+112	2.2173667408153426e+116
15.0ms	-5.242421858321456e+212	-1.7427364689877398e+197

Samples

14.0ms	274×	0	valid
1.0ms	14×	1	valid

Compiler

Compiled 176 to 248 computations (-40.9% saved)

Precisions

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

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

adjust: 0.0ms (0% of total)

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

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

bsearch16.0ms (0.3%)

Memory

-9.8MiB live, 28.7MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
14.0ms	800059.6106337856	126892797710992.06
1.0ms	-2.8486521699381002e+69	-7.591119707449266e+68

Samples

6.0ms	135×	0	valid
1.0ms	7×	1	valid
0.0ms	2×	2	valid

Compiler

Compiled 126 to 196 computations (-55.6% saved)

Precisions

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

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

adjust: 0.0ms (0% of total)

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

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

simplify24.0ms (0.5%)

Memory

12.7MiB live, 51.8MiB allocated

Algorithm

1×	egg-herbie

Rules

4×	`+-commutative-binary64-+.f64`
2×	`-commutative-binary64-.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	45	244
1	48	244

Stop Event

1×

saturated

Calls

Call 1

Inputs
(fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x))
(if (<=.f64 z #s(literal -26999999999999999348982840542776747803110975295984016463401287659010289567960924160 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z)) (if (<=.f64 z #s(literal 1349999999999999967449142027138837390155548764799200823170064382950514478398046208 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y))) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))))
(if (<=.f64 x #s(literal -1150000000000000083411151838758620395082130571093500248845941678800896 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z)) (if (<=.f64 x #s(literal 6427752177035961/25711008708143844408671393477458601640355247900524685364822016 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))))
(if (<=.f64 y #s(literal -219999999999999989251524342063172905174561530146096767388264845592617257922499102032124533561791485018109259872877041647552861571512154848037986190378081987862948063844215350017099203841039896936448 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y)) (if (<=.f64 y #s(literal 134999999999999997726019727911999959531202734349100562798580166571737687605700807120867029239779558989261493871050752 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))))
(if (<=.f64 x #s(literal -1150000000000000083411151838758620395082130571093500248845941678800896 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (.f64 #s(literal 3 binary64) x)) (if (<=.f64 x #s(literal 750000000 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (.f64 #s(literal 3 binary64) x))))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))

Outputs
(fma.f64 #s(literal 2 binary64) (+.f64 y x) (+.f64 z x))
(fma.f64 #s(literal 2 binary64) (+.f64 x y) (+.f64 z x))
(if (<=.f64 z #s(literal -26999999999999999348982840542776747803110975295984016463401287659010289567960924160 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z)) (if (<=.f64 z #s(literal 1349999999999999967449142027138837390155548764799200823170064382950514478398046208 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y))) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))))
(if (<=.f64 x #s(literal -1150000000000000083411151838758620395082130571093500248845941678800896 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z)) (if (<=.f64 x #s(literal 6427752177035961/25711008708143844408671393477458601640355247900524685364822016 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))))
(if (<=.f64 y #s(literal -219999999999999989251524342063172905174561530146096767388264845592617257922499102032124533561791485018109259872877041647552861571512154848037986190378081987862948063844215350017099203841039896936448 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y)) (if (<=.f64 y #s(literal 134999999999999997726019727911999959531202734349100562798580166571737687605700807120867029239779558989261493871050752 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))))
(if (<=.f64 x #s(literal -1150000000000000083411151838758620395082130571093500248845941678800896 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (.f64 #s(literal 3 binary64) x)) (if (<=.f64 x #s(literal 750000000 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (.f64 #s(literal 3 binary64) x))))
#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))

soundness828.0ms (16.9%)

Memory

6.7MiB live, 496.9MiB allocated

Rules

10 710×	`lower-fma.f64`
10 710×	`lower-fma.f32`
5 592×	`lower-*.f32`
5 590×	`lower-*.f64`
5 184×	`lower-fma.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	8	35
0	13	35
1	81	29
2	878	29
0	8130	26
0	20	100
0	28	100
1	149	87
2	1669	87
0	8249	85
0	113	764
1	343	762
2	900	762
3	2786	762
4	6677	762
0	8202	658
0	21	90
0	29	90
1	158	78
2	1770	78
0	8225	78

Stop Event

1×	done
1×	iter limit
1×	node limit
1×	iter 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

Compiler

Compiled 177 to 130 computations (26.6% saved)

preprocess53.0ms (1.1%)

Memory: -31.1MiB live, 86.2MiB allocated
Compiler: Compiled 224 to 96 computations (57.1% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

start0.0ms (0%)

analyze0.0ms (0%)

sample1.0s (20.8%)

explain377.0ms (7.7%)

preprocess336.0ms (6.8%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify7.0ms (0.1%)

localize81.0ms (1.6%)

series8.0ms (0.2%)

simplify186.0ms (3.8%)

rewrite355.0ms (7.2%)

eval93.0ms (1.9%)

prune17.0ms (0.4%)

simplify8.0ms (0.2%)

localize49.0ms (1%)

series16.0ms (0.3%)

simplify129.0ms (2.6%)

rewrite150.0ms (3.1%)

eval54.0ms (1.1%)

prune19.0ms (0.4%)

simplify10.0ms (0.2%)

localize66.0ms (1.4%)

series13.0ms (0.3%)

simplify136.0ms (2.8%)

rewrite165.0ms (3.4%)

eval100.0ms (2%)

prune14.0ms (0.3%)

simplify8.0ms (0.2%)

localize32.0ms (0.6%)

series7.0ms (0.1%)

simplify122.0ms (2.5%)

rewrite175.0ms (3.6%)

eval49.0ms (1%)

prune10.0ms (0.2%)

regimes21.0ms (0.4%)

regimes20.0ms (0.4%)

regimes6.0ms (0.1%)

regimes5.0ms (0.1%)

regimes12.0ms (0.2%)

regimes6.0ms (0.1%)

bsearch49.0ms (1%)

bsearch19.0ms (0.4%)

bsearch29.0ms (0.6%)

bsearch16.0ms (0.3%)

simplify24.0ms (0.5%)

soundness828.0ms (16.9%)

preprocess53.0ms (1.1%)

end0.0ms (0%)

Profiling