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.4MiB live, 0.4MiB 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)

sample703.0ms (15.8%)

Memory

17.2MiB live, 1 275.2MiB allocated

Samples

380.0ms	7 817×	0	valid
35.0ms	296×	1	valid
22.0ms	109×	2	valid
7.0ms	34×	3	valid

Precisions

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

ival-add: 217.0ms (88.7% of total)

adjust: 17.0ms (7% of total)

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

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

Bogosity

explain112.0ms (2.5%)

Memory

-5.1MiB live, 154.5MiB 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

32.0ms	490×	0	valid
2.0ms	16×	1	valid
1.0ms	6×	2	valid

Compiler

Compiled 129 to 36 computations (72.1% saved)

Precisions

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

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

adjust: 1.0ms (7.2% of total)

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

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

preprocess344.0ms (7.8%)

Memory

0.1MiB live, 36.1MiB allocated

Algorithm

1×	egg-herbie

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.7MiB live, 0.7MiB allocated
Compiler: Compiled 0 to 3 computations (-∞% saved)

prune0.0ms (0%)

Memory

1.1MiB live, 1.1MiB 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)

simplify6.0ms (0.1%)

Memory

8.7MiB live, 8.7MiB 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)

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

localize27.0ms (0.6%)

Memory

-5.5MiB live, 30.5MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0	(+.f64 x y)
accuracy	0.0234375	(+.f64 (+.f64 x y) y)
accuracy	0.03125	(+.f64 (+.f64 (+.f64 x y) y) x)
accuracy	0.0390625	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)

Samples

14.0ms	245×	0	valid
1.0ms	8×	1	valid
1.0ms	3×	2	valid

Compiler

Compiled 78 to 18 computations (76.9% saved)

Precisions

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

ival-add: 6.0ms (88.4% of total)

adjust: 0.0ms (0% of total)

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

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

series8.0ms (0.2%)

Memory

13.6MiB live, 13.6MiB 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	x	@	inf	((+ (+ (+ (+ x y) y) x) z) (+ (+ (+ x y) y) x) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (+ x y) y) (+ x y))
0.0ms	z	@	-inf	((+ (+ (+ (+ x y) y) x) z) (+ (+ (+ x y) y) x) (+ (+ (+ (+ (+ x y) y) x) z) x) (+ (+ x y) y) (+ x y))

simplify151.0ms (3.4%)

Memory

3.2MiB live, 120.6MiB allocated

Algorithm

1×	egg-herbie

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)

rewrite195.0ms (4.4%)

Memory

-20.5MiB live, 314.6MiB allocated

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>

eval94.0ms (2.1%)

Memory: -13.2MiB live, 223.7MiB allocated
Compiler: Compiled 23 039 to 2 484 computations (89.2% saved)

prune16.0ms (0.4%)

Memory

9.1MiB live, 48.3MiB 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
	40.0%	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64))) x)
▶	99.9%	(+.f64 z (fma.f64 #s(literal 2 binary64) (+.f64 y x) x))
▶	65.8%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
	67.8%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64))))
▶	66.9%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
▶	34.8%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 y #s(literal 2 binary64)))
▶	35.1%	#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

14.5MiB live, 14.5MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 11 expressions of interest:

New	Metric	Score
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	-128	(fma.f64 #s(literal 2 binary64) (+.f64 y x) x)
cost-diff	0	(+.f64 y x)
cost-diff	128	(+.f64 z (fma.f64 #s(literal 2 binary64) (+.f64 y x) x))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	21	107
0	29	107
1	57	95
2	114	95
3	214	95
4	283	95
5	285	95
0	285	90

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

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

localize48.0ms (1.1%)

Memory

-5.5MiB live, 71.4MiB allocated

Localize:

Found 11 expressions of interest:

New	Metric	Score
accuracy	0	(fma.f64 y #s(literal 2 binary64) z)
accuracy	21.871931511713367	#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.200892855623053	#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.71046282107112	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 y #s(literal 2 binary64)))
accuracy	0	(*.f64 #s(literal 3 binary64) x)
accuracy	41.539190393742324	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))
accuracy	0	(+.f64 y x)
accuracy	0.03125	(+.f64 z (fma.f64 #s(literal 2 binary64) (+.f64 y x) x))
accuracy	0.08203125	(fma.f64 #s(literal 2 binary64) (+.f64 y x) x)

Samples

28.0ms	228×	0	valid
5.0ms	18×	1	valid
3.0ms	8×	2	valid
1.0ms	2×	3	valid

Compiler

Compiled 158 to 36 computations (77.2% saved)

Precisions

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

ival-add: 14.0ms (66.3% of total)

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

adjust: 2.0ms (9.5% of total)

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

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

exact: 0.0ms (0% of total)

series17.0ms (0.4%)

Memory

-18.3MiB live, 25.5MiB allocated

Counts

11 → 300

Calls

Call 1

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

simplify114.0ms (2.6%)

Memory

27.7MiB live, 140.6MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	125	1850
1	376	1850
2	967	1850
3	3048	1850
4	6693	1850
0	8068	1511

Stop Event

1×	iter limit
1×	node limit

Counts

300 → 278

Calls

Call 1

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

rewrite188.0ms (4.2%)

Memory

-14.0MiB live, 228.9MiB allocated

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	21	93
0	29	93
1	159	81
2	1761	81
0	8329	81

Stop Event

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

Counts

11 → 484

Calls

Call 1

Inputs
(+.f64 z (fma.f64 #s(literal 2 binary64) (+.f64 y x) x))
(+.f64 y x)
(fma.f64 #s(literal 2 binary64) (+.f64 y x) 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>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<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 (2.1%)

Memory: -0.2MiB live, 151.4MiB allocated
Compiler: Compiled 23 838 to 1 822 computations (92.4% saved)

prune21.0ms (0.5%)

Memory

14.7MiB live, 53.5MiB allocated

Pruning

7 alts after pruning (3 fresh and 4 done)

	Pruned	Kept	Total
New	761	1	762
Fresh	0	2	2
Picked	1	4	5
Done	0	0	0
Total	762	7	769

Accuracy

100.0%

Counts

769 → 7

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	40.0%	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64))) x)
✓	99.9%	(+.f64 z (fma.f64 #s(literal 2 binary64) (+.f64 y x) x))
✓	65.8%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
▶	67.8%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64))))
✓	66.9%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
▶	34.8%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
✓	35.1%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))

Compiler

Compiled 39 to 45 computations (-15.4% saved)

simplify7.0ms (0.2%)

Memory

9.1MiB live, 9.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 8 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 #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))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	17	84
0	22	84
1	40	76
2	86	76
3	186	74
4	273	74
5	277	74
0	277	70

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

localize35.0ms (0.8%)

Memory

14.1MiB live, 52.5MiB allocated

Localize:

Found 8 expressions of interest:

New	Metric	Score
accuracy	0	(*.f64 y #s(literal 2 binary64))
accuracy	0.0390625	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64))) x)
accuracy	41.69861337698497	#s(approx (+ (+ (+ (+ x y) y) x) z) (*.f64 y #s(literal 2 binary64)))
accuracy	0	(fma.f64 #s(literal 3 binary64) x (*.f64 y #s(literal 2 binary64)))
accuracy	0	(*.f64 y #s(literal 2 binary64))
accuracy	20.624720225891807	#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.71046282107112	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))

Samples

22.0ms	238×	0	valid
2.0ms	11×	1	valid
2.0ms	6×	2	valid
0.0ms	1×	3	valid

Compiler

Compiled 112 to 28 computations (75% saved)

Precisions

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

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

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

adjust: 1.0ms (7.5% of total)

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

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

exact: 0.0ms (0% of total)

series12.0ms (0.3%)

Memory

-31.5MiB live, 14.6MiB allocated

Counts

7 → 192

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 (+.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 (+.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 (+.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 (+.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 (+.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 (+.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 (+.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 (+.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 (+.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 (+.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
2.0ms	z	@	-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) (+ (+ (+ (+ 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) (+ (+ (+ (+ 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) (+ (+ (+ (+ x y) y) x) z))
0.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) (+ (+ (+ (+ x y) y) x) z))
0.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) (+ (+ (+ (+ x y) y) x) z))

simplify108.0ms (2.4%)

Memory

14.8MiB live, 127.7MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	91	1262
1	271	1256
2	738	1256
3	2051	1256
4	4509	1256
0	8381	1038

Stop Event

1×	iter limit
1×	node limit

Counts

192 → 184

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))))
(+ (* 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)))))
(* 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 (/ (+ (* 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))))
(+ 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)) (/ 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 (/ (+ 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)))
(+ 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))))
(* 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)))
(* 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))
(+ (* 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)))))
(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 (/ (+ (* 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))
(+ 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)) (/ 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 (/ (+ 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))
(+ 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))
(* 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))
(* 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)

rewrite173.0ms (3.9%)

Memory

-2.4MiB live, 237.5MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	17	73
0	22	73
1	122	65
2	1282	65
0	8410	61

Stop Event

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

Counts

7 → 294

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))
(+.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>

eval64.0ms (1.4%)

Memory: -2.5MiB live, 117.4MiB allocated
Compiler: Compiled 6 923 to 995 computations (85.6% saved)

prune42.0ms (0.9%)

Memory

-6.3MiB live, 32.9MiB allocated

Pruning

7 alts after pruning (2 fresh and 5 done)

	Pruned	Kept	Total
New	586	2	588
Fresh	0	0	0
Picked	2	1	3
Done	0	4	4
Total	588	7	595

Accuracy

100.0%

Counts

595 → 7

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	40.0%	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x)
✓	99.9%	(+.f64 z (fma.f64 #s(literal 2 binary64) (+.f64 y x) x))
✓	65.8%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
▶	67.8%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y)))
✓	66.9%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
✓	34.8%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
✓	35.1%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))

Compiler

Compiled 39 to 43 computations (-10.3% saved)

simplify7.0ms (0.2%)

Memory

7.0MiB live, 7.0MiB 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))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	14	63
0	18	63
1	37	57
2	84	57
3	185	56
4	284	56
5	288	56
0	288	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

localize54.0ms (1.2%)

Memory

9.2MiB live, 46.2MiB allocated

Localize:

Found 6 expressions of interest:

New	Metric	Score
accuracy	0	(+.f64 y y)
accuracy	0.0390625	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x)
accuracy	41.69861337698497	#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	20.624720225891807	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y)))

Samples

44.0ms	238×	0	valid
2.0ms	11×	1	valid
1.0ms	6×	2	valid
0.0ms	1×	3	valid

Compiler

Compiled 85 to 23 computations (72.9% saved)

Precisions

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

ival-add: 34.0ms (91.9% of total)

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

adjust: 1.0ms (2.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.2%)

Memory

11.5MiB live, 11.5MiB 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
1.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	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))
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))

simplify127.0ms (2.9%)

Memory

6.5MiB live, 127.1MiB allocated

Algorithm

1×	egg-herbie

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)

rewrite269.0ms (6.1%)

Memory

-6.3MiB live, 194.6MiB allocated

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>

eval50.0ms (1.1%)

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

prune9.0ms (0.2%)

Memory

35.6MiB live, 35.6MiB 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
✓	40.0%	(+.f64 #s(approx (+ (+ (+ (+ x y) y) x) z) (+.f64 y y)) x)
✓	99.9%	(+.f64 z (fma.f64 #s(literal 2 binary64) (+.f64 y x) x))
✓	65.8%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z))
✓	67.8%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x (+.f64 y y)))
✓	66.9%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z))
✓	34.8%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y))
✓	35.1%	#s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (*.f64 #s(literal 3 binary64) x))

Compiler

Compiled 106 to 74 computations (30.2% saved)

regimes18.0ms (0.4%)

Memory

-4.3MiB live, 34.2MiB allocated

Counts

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

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

Calls

4 calls:

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

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)

regimes25.0ms (0.6%)

Memory

-8.7MiB live, 29.2MiB allocated

Counts

9 → 4

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 #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 y #s(literal 2 binary64) 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 #s(literal 3 binary64) x z))

Calls

4 calls:

13.0ms	z
4.0ms	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)
4.0ms	y
3.0ms	x

Results

Accuracy	Segments	Branch
88.1%	4	`x`
87.4%	3	`y`
90.1%	4	`z`
74.0%	3	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)`

Compiler

Compiled 14 to 17 computations (-21.4% saved)

regimes7.0ms (0.1%)

Memory

13.3MiB live, 13.3MiB 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 y #s(literal 2 binary64) z))

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

Calls

2 calls:

3.0ms	z
3.0ms	y

Results

Accuracy	Segments	Branch
87.4%	3	`y`
80.7%	7	`z`

Compiler

Compiled 2 to 6 computations (-200% saved)

regimes35.0ms (0.8%)

Memory

-33.0MiB live, 13.1MiB 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:

32.0ms	x
2.0ms	y

Results

Accuracy	Segments	Branch
66.9%	1	`x`
82.0%	3	`y`

Compiler

Compiled 2 to 6 computations (-200% saved)

regimes8.0ms (0.2%)

Memory

28.3MiB live, 28.3MiB 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 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))

Calls

4 calls:

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

Results

Accuracy	Segments	Branch
54.2%	3	`x`
44.2%	5	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 x y) y) x) z) x)`
44.4%	4	`z`
55.5%	3	`y`

Compiler

Compiled 14 to 17 computations (-21.4% saved)

regimes8.0ms (0.2%)

Memory

-12.3MiB live, 25.4MiB 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:

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

Results

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

Compiler

Compiled 14 to 17 computations (-21.4% saved)

bsearch100.0ms (2.3%)

Memory

-6.5MiB live, 68.0MiB allocated

Algorithm

3×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
12.0ms	1.0397426551732109e+92	5.977946125825428e+97
9.0ms	-3.3860187493814536e+83	-5.321502925590169e+82
73.0ms	-2.1358434039351004e+185	-7.964311932827107e+172

Samples

77.0ms	388×	0	valid
1.0ms	12×	1	valid

Compiler

Compiled 294 to 379 computations (-28.9% saved)

Precisions

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

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

adjust: 0.0ms (0% of total)

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

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

bsearch23.0ms (0.5%)

Memory

-9.8MiB live, 36.0MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
13.0ms	1.4547236398357148e+116	3.097455202865517e+117
8.0ms	-4.1306398833818844e+73	-3.401011239784485e+72

Samples

9.0ms	200×	0	valid
1.0ms	8×	1	valid

Compiler

Compiled 144 to 196 computations (-36.1% saved)

Precisions

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

ival-add: 5.0ms (96.4% of total)

adjust: 0.0ms (0% of total)

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

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

bsearch23.0ms (0.5%)

Memory

35.1MiB live, 35.1MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
9.0ms	8.961024430429547e+161	1.6956187555548272e+164
11.0ms	-8.315883686437338e+94	-5.2757888875455625e+90

Samples

11.0ms	236×	0	valid
0.0ms	4×	1	valid

Compiler

Compiled 149 to 209 computations (-40.3% saved)

Precisions

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

ival-add: 5.0ms (87.4% of total)

adjust: 0.0ms (0% of total)

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

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

bsearch8.0ms (0.2%)

Memory

-26.5MiB live, 12.2MiB allocated

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
4.0ms	1.4547236398357148e+116	3.097455202865517e+117
2.0ms	-4.1306398833818844e+73	-3.401011239784485e+72

Samples

2.0ms	46×	0	valid
0.0ms	2×	1	valid

Compiler

Compiled 118 to 183 computations (-55.1% saved)

Precisions

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

ival-add: 1.0ms (78.2% of total)

adjust: 0.0ms (0% of total)

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

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

simplify50.0ms (1.1%)

Memory

5.5MiB live, 44.0MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	48	264
1	51	264

Stop Event

1×

saturated

Calls

Call 1

Inputs
(+.f64 z (fma.f64 #s(literal 2 binary64) (+.f64 y x) x))
(if (<=.f64 z #s(literal -8600000000000000738898301499318608487981932624712402132747493600576197696336554870043628037538781250168907097967576530528175325990298317855818803797744607350307511647074355511296 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z)) (if (<=.f64 z #s(literal -174999999999999988541199398449770087192909677626106685082441788033616673570073608192 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z)) (if (<=.f64 z #s(literal 125000000000000005422162121827398259161286665618992413973971723667014601611210138867665469440 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 #s(literal 3 binary64) x z)))))
(if (<=.f64 y #s(literal -10999999999999999970298208129241602874234723844944782356581185731124264960 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z)) (if (<=.f64 y #s(literal 1000000000000000050555427725995033814228237030803003279020481474722232763977085405824233377105062219252417113236701184 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))))
(if (<=.f64 y #s(literal -60000000000000001213132747629356819314565779392861464468266611372480240299889858561521869651968 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y)) (if (<=.f64 y #s(literal 4800000000000000181180287591495114579175855261537390892788156229768460894601861010422805468143405942966537332737458992564692750298818793552471415958048069772115968 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 y #s(literal -10999999999999999970298208129241602874234723844944782356581185731124264960 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y)) (if (<=.f64 y #s(literal 1180000000000000000862105234506779373656459831425881568550973837762684370368246878573058766504748602469817995239620608 binary64)) #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 y y))

Outputs
(+.f64 z (fma.f64 #s(literal 2 binary64) (+.f64 y x) x))
(+.f64 (fma.f64 #s(literal 2 binary64) (+.f64 x y) x) z)
(if (<=.f64 z #s(literal -8600000000000000738898301499318608487981932624712402132747493600576197696336554870043628037538781250168907097967576530528175325990298317855818803797744607350307511647074355511296 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 #s(literal 3 binary64) x z)) (if (<=.f64 z #s(literal -174999999999999988541199398449770087192909677626106685082441788033616673570073608192 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z)) (if (<=.f64 z #s(literal 125000000000000005422162121827398259161286665618992413973971723667014601611210138867665469440 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 #s(literal 3 binary64) x z)))))
(if (<=.f64 y #s(literal -10999999999999999970298208129241602874234723844944782356581185731124264960 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (fma.f64 y #s(literal 2 binary64) z)) (if (<=.f64 y #s(literal 1000000000000000050555427725995033814228237030803003279020481474722232763977085405824233377105062219252417113236701184 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))))
(if (<=.f64 y #s(literal -60000000000000001213132747629356819314565779392861464468266611372480240299889858561521869651968 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y)) (if (<=.f64 y #s(literal 4800000000000000181180287591495114579175855261537390892788156229768460894601861010422805468143405942966537332737458992564692750298818793552471415958048069772115968 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 y #s(literal -10999999999999999970298208129241602874234723844944782356581185731124264960 binary64)) #s(approx (+ (+ (+ (+ (+ x y) y) x) z) x) (+.f64 y y)) (if (<=.f64 y #s(literal 1180000000000000000862105234506779373656459831425881568550973837762684370368246878573058766504748602469817995239620608 binary64)) #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 y y))

soundness951.0ms (21.4%)

Memory

4.5MiB live, 616.4MiB allocated

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
0	8	35
0	13	35
1	81	29
2	878	29
0	8130	26
0	21	93
0	29	93
1	159	81
2	1761	81
0	8329	81
0	17	73
0	22	73
1	122	65
2	1282	65
0	8410	61

Stop Event

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

Compiler

Compiled 194 to 135 computations (30.4% saved)

preprocess76.0ms (1.7%)

Memory: 11.6MiB live, 86.5MiB allocated
Compiler: Compiled 242 to 102 computations (57.9% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

start0.0ms (0%)

analyze0.0ms (0%)

sample703.0ms (15.8%)

explain112.0ms (2.5%)

preprocess344.0ms (7.8%)

eval0.0ms (0%)

prune0.0ms (0%)

simplify6.0ms (0.1%)

localize27.0ms (0.6%)

series8.0ms (0.2%)

simplify151.0ms (3.4%)

rewrite195.0ms (4.4%)

eval94.0ms (2.1%)

prune16.0ms (0.4%)

simplify8.0ms (0.2%)

localize48.0ms (1.1%)

series17.0ms (0.4%)

simplify114.0ms (2.6%)

rewrite188.0ms (4.2%)

eval93.0ms (2.1%)

prune21.0ms (0.5%)

simplify7.0ms (0.2%)

localize35.0ms (0.8%)

series12.0ms (0.3%)

simplify108.0ms (2.4%)

rewrite173.0ms (3.9%)

eval64.0ms (1.4%)

prune42.0ms (0.9%)

simplify7.0ms (0.2%)

localize54.0ms (1.2%)

series7.0ms (0.2%)

simplify127.0ms (2.9%)

rewrite269.0ms (6.1%)

eval50.0ms (1.1%)

prune9.0ms (0.2%)

regimes18.0ms (0.4%)

regimes25.0ms (0.6%)

regimes7.0ms (0.1%)

regimes35.0ms (0.8%)

regimes8.0ms (0.2%)

regimes8.0ms (0.2%)

bsearch100.0ms (2.3%)

bsearch23.0ms (0.5%)

bsearch23.0ms (0.5%)

bsearch8.0ms (0.2%)

simplify50.0ms (1.1%)

soundness951.0ms (21.4%)

preprocess76.0ms (1.7%)

end0.0ms (0%)

Profiling