Commute and associate

Time bar (total: 4.6s)

start0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

analyze0.0ms (0%)

Memory
0.3MiB live, 0.3MiB allocated
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
0%0%99.9%0.1%0%0%0%0
100%99.9%0%0.1%0%0%0%1
Compiler

Compiled 13 to 10 computations (23.1% saved)

sample1.9s (40%)

Memory
38.6MiB live, 1 507.8MiB allocated
Samples
772.0ms4 327×1valid
696.0ms3 921×2valid
0.0ms8×0valid
Precisions
Click to see histograms. Total time spent on operations: 1.1s
adjust: 571.0ms (51.3% of total)
ival-add: 451.0ms (40.5% of total)
ival-sub: 83.0ms (7.5% of total)
ival-true: 5.0ms (0.4% of total)
ival-assert: 3.0ms (0.3% of total)
Bogosity

explain162.0ms (3.5%)

Memory
-6.7MiB live, 123.8MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
00-0-(+.f64 (+.f64 x y) z)
00-0-(+.f64 y z)
00-0-y
00-0-(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
00-0-(+.f64 x y)
00-0-(+.f64 x (+.f64 y z))
00-0-z
00-0-x
Confusion
Predicted +Predicted -
+01
-0255
Precision
0/0
Recall
0.0
Confusion?
Predicted +Predicted MaybePredicted -
+001
-00255
Precision?
0/0
Recall?
0.0
Freqs
test
numberfreq
0256
Total Confusion?
Predicted +Predicted MaybePredicted -
+001
-000
Precision?
0/0
Recall?
0.0
Samples
72.0ms268×2valid
31.0ms242×1valid
0.0ms2×0valid
Compiler

Compiled 78 to 28 computations (64.1% saved)

Precisions
Click to see histograms. Total time spent on operations: 47.0ms
adjust: 21.0ms (45% of total)
ival-add: 20.0ms (42.9% of total)
ival-sub: 5.0ms (10.7% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)

preprocess458.0ms (9.9%)

Memory
15.5MiB live, 274.4MiB allocated
Algorithm
1×egg-herbie
Rules
14 508×lower-fma.f64
14 508×lower-fma.f32
3 456×unsub-neg
3 206×associate-+r+
2 832×lower-+.f32
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
036117
11229
25259
316609
425109
527669
627779
727859
827859
927859
1027859
1127859
0811
01311
1261
2901
33611
411621
518081
638801
750441
858721
963261
1063601
1163641
1264821
1364911
1464921
1564921
1664921
1773411
1874931
1976451
2077591
2177971
2277971
081811
Stop Event
1×iter limit
1×node limit
1×iter limit
1×node limit
Calls
Call 1
Inputs
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
Outputs
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
#s(literal 0 binary64)
Symmetry

(abs z)

(abs y)

(abs x)

(negabs z)

(negabs y)

(negabs x)

(sort x y z)

Compiler

Compiled 14 to 8 computations (42.9% saved)

eval0.0ms (0%)

Memory
0.3MiB live, 0.3MiB allocated
Compiler

Compiled 3 to 3 computations (0% saved)

prune1.0ms (0%)

Memory
1.1MiB live, 1.1MiB allocated
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶99.8%
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
Compiler

Compiled 14 to 8 computations (42.9% saved)

simplify337.0ms (7.3%)

Memory
-0.6MiB live, 126.1MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
cost-diff0
(+.f64 x (+.f64 y z))
cost-diff0
(+.f64 x y)
cost-diff0
(+.f64 (+.f64 x y) z)
cost-diff960
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
Rules
14 508×lower-fma.f64
14 508×lower-fma.f32
3 456×unsub-neg
2 832×lower-+.f32
2 824×lower-+.f64
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
0830
01330
12620
29020
336120
4116220
5180820
6388020
7504420
8587220
9632620
10636020
11636420
12648220
13649120
14649220
15649220
16649220
17734120
18749320
19764520
20775920
21779720
22779720
0818120
Stop Event
1×iter limit
1×node limit
1×iter limit
Calls
Call 1
Inputs
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
x
y
z
(+.f64 x (+.f64 y z))
(+.f64 y z)
Outputs
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
#s(literal 0 binary64)
(+.f64 (+.f64 x y) z)
(+.f64 x (+.f64 y z))
(+.f64 x y)
x
y
z
(+.f64 x (+.f64 y z))
(+.f64 y z)

localize67.0ms (1.4%)

Memory
-8.7MiB live, 60.2MiB allocated
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
accuracy0
(+.f64 (+.f64 x y) z)
accuracy0
(+.f64 y z)
accuracy0
(+.f64 x y)
accuracy0.00390625
(+.f64 x (+.f64 y z))
Samples
43.0ms134×2valid
13.0ms121×1valid
0.0ms1×0valid
Compiler

Compiled 32 to 10 computations (68.8% saved)

Precisions
Click to see histograms. Total time spent on operations: 23.0ms
ival-add: 10.0ms (43.8% of total)
adjust: 10.0ms (43.8% of total)
ival-sub: 2.0ms (8.8% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)

series5.0ms (0.1%)

Memory
4.5MiB live, 4.5MiB allocated
Counts
5 → 156
Calls
Call 1
Inputs
#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())
#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())
#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())
#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())
#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())
Outputs
#s(alt 0 (taylor 0 x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) (patch (-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z))) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (/ y x) (/ z x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (/ y x) (/ z x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (/ y x) (/ z x)))) (taylor inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt x (taylor -inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1))) (taylor -inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1))) (taylor -inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1))) (taylor -inf x) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x z) (taylor 0 y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt y (taylor inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (+ (/ x y) (/ z y)))) (taylor inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (+ (/ x y) (/ z y)))) (taylor inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (+ (/ x y) (/ z y)))) (taylor inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt y (taylor -inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1))) (taylor -inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1))) (taylor -inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1))) (taylor -inf y) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x y) (taylor 0 z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ x z) (/ y z)))) (taylor inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ x z) (/ y z)))) (taylor inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ x z) (/ y z)))) (taylor inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 x y) z) (patch (+.f64 (+.f64 x y) z) #<representation binary64>) () ())) ())
#s(alt 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 x (taylor inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (/ y x))) (taylor inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (/ y x))) (taylor inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (/ y x))) (taylor inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt x (taylor -inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ y x)) 1))) (taylor -inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ y x)) 1))) (taylor -inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ y x)) 1))) (taylor -inf x) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt x (taylor 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 y (taylor inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (/ x y))) (taylor inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (/ x y))) (taylor inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (/ x y))) (taylor inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt y (taylor -inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ x y)) 1))) (taylor -inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ x y)) 1))) (taylor -inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ x y)) 1))) (taylor -inf y) (#s(alt (+.f64 x y) (patch (+.f64 x y) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt x (taylor inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (/ y x) (/ z x)))) (taylor inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (/ y x) (/ z x)))) (taylor inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ 1 (+ (/ y x) (/ z x)))) (taylor inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt x (taylor -inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1))) (taylor -inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1))) (taylor -inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (- (* -1 (/ (+ y z) x)) 1))) (taylor -inf x) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x z) (taylor 0 y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt y (taylor inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (+ (/ x y) (/ z y)))) (taylor inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (+ (/ x y) (/ z y)))) (taylor inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (+ (/ x y) (/ z y)))) (taylor inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt y (taylor -inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1))) (taylor -inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1))) (taylor -inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ (+ x z) y)) 1))) (taylor -inf y) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x y) (taylor 0 z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (+ x (+ y z)) (taylor 0 z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ x z) (/ y z)))) (taylor inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ x z) (/ y z)))) (taylor inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ x z) (/ y z)))) (taylor inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1))) (taylor -inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1))) (taylor -inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ x y) z)) 1))) (taylor -inf z) (#s(alt (+.f64 x (+.f64 y z)) (patch (+.f64 x (+.f64 y z)) #<representation binary64>) () ())) ())
#s(alt z (taylor 0 y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt y (taylor inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (/ z y))) (taylor inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (/ z y))) (taylor inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* y (+ 1 (/ z y))) (taylor inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt y (taylor -inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ z y)) 1))) (taylor -inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ z y)) 1))) (taylor -inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (- (* -1 (/ z y)) 1))) (taylor -inf y) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt y (taylor 0 z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (+ y z) (taylor 0 z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (/ y z))) (taylor inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (/ y z))) (taylor inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (/ y z))) (taylor inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ y z)) 1))) (taylor -inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ y z)) 1))) (taylor -inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ y z)) 1))) (taylor -inf z) (#s(alt (+.f64 y z) (patch (+.f64 y z) #<representation binary64>) () ())) ())
Calls

39 calls:

TimeVariablePointExpression
0.0ms
x
@inf
(+ (+ x y) z)
0.0ms
y
@inf
(+ (+ x y) z)
0.0ms
z
@-inf
(+ (+ x y) z)
0.0ms
z
@inf
(+ (+ x y) z)
0.0ms
y
@-inf
(+ (+ x y) z)

simplify316.0ms (6.8%)

Memory
-17.9MiB live, 140.1MiB allocated
Algorithm
1×egg-herbie
Rules
15 312×lower-fma.f64
15 312×lower-fma.f32
5 296×lower-/.f32
5 296×lower-/.f64
2 424×lower-*.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
064456
1188456
2477456
31435456
43496456
54400456
64902456
75035456
85053456
95053456
08893456
Stop Event
1×iter limit
1×node limit
Counts
156 → 132
Calls
Call 1
Inputs
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
(+ y z)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
x
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+ x z)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
y
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+ x y)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
y
(+ x y)
(+ x y)
(+ x y)
x
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
(* x (+ 1 (/ y x)))
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
(* -1 (* x (- (* -1 (/ y x)) 1)))
x
(+ x y)
(+ x y)
(+ x y)
y
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
(* y (+ 1 (/ x y)))
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+ y z)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
x
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
(* x (+ 1 (+ (/ y x) (/ z x))))
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+ x z)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
y
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
(* y (+ 1 (+ (/ x y) (/ z y))))
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+ x y)
(+ x (+ y z))
(+ x (+ y z))
(+ x (+ y z))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
(* z (+ 1 (+ (/ x z) (/ y z))))
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
z
(+ y z)
(+ y z)
(+ y z)
y
(* y (+ 1 (/ z y)))
(* y (+ 1 (/ z y)))
(* y (+ 1 (/ z y)))
y
(* -1 (* y (- (* -1 (/ z y)) 1)))
(* -1 (* y (- (* -1 (/ z y)) 1)))
(* -1 (* y (- (* -1 (/ z y)) 1)))
y
(+ y z)
(+ y z)
(+ y z)
z
(* z (+ 1 (/ y z)))
(* z (+ 1 (/ y z)))
(* z (+ 1 (/ y z)))
z
(* -1 (* z (- (* -1 (/ y z)) 1)))
(* -1 (* z (- (* -1 (/ y z)) 1)))
(* -1 (* z (- (* -1 (/ y z)) 1)))
Outputs
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
(+ y z)
(+.f64 y z)
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
x
(* x (+ 1 (+ (/ y x) (/ z x))))
(+.f64 y (+.f64 z x))
(* x (+ 1 (+ (/ y x) (/ z x))))
(+.f64 y (+.f64 z x))
(* x (+ 1 (+ (/ y x) (/ z x))))
(+.f64 y (+.f64 z x))
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+.f64 y (+.f64 z x))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+.f64 y (+.f64 z x))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+.f64 y (+.f64 z x))
(+ x z)
(+.f64 z x)
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
y
(* y (+ 1 (+ (/ x y) (/ z y))))
(+.f64 y (+.f64 z x))
(* y (+ 1 (+ (/ x y) (/ z y))))
(+.f64 y (+.f64 z x))
(* y (+ 1 (+ (/ x y) (/ z y))))
(+.f64 y (+.f64 z x))
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+.f64 y (+.f64 z x))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+.f64 y (+.f64 z x))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+.f64 y (+.f64 z x))
(+ x y)
(+.f64 y x)
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(+.f64 y (+.f64 z x))
(* z (+ 1 (+ (/ x z) (/ y z))))
(+.f64 y (+.f64 z x))
(* z (+ 1 (+ (/ x z) (/ y z))))
(+.f64 y (+.f64 z x))
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(+.f64 y (+.f64 z x))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(+.f64 y (+.f64 z x))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(+.f64 y (+.f64 z x))
y
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
x
(* x (+ 1 (/ y x)))
(+.f64 y x)
(* x (+ 1 (/ y x)))
(+.f64 y x)
(* x (+ 1 (/ y x)))
(+.f64 y x)
x
(* -1 (* x (- (* -1 (/ y x)) 1)))
(+.f64 y x)
(* -1 (* x (- (* -1 (/ y x)) 1)))
(+.f64 y x)
(* -1 (* x (- (* -1 (/ y x)) 1)))
(+.f64 y x)
x
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
(+ x y)
(+.f64 y x)
y
(* y (+ 1 (/ x y)))
(+.f64 y x)
(* y (+ 1 (/ x y)))
(+.f64 y x)
(* y (+ 1 (/ x y)))
(+.f64 y x)
y
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+.f64 y x)
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+.f64 y x)
(* -1 (* y (- (* -1 (/ x y)) 1)))
(+.f64 y x)
(+ y z)
(+.f64 y z)
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
x
(* x (+ 1 (+ (/ y x) (/ z x))))
(+.f64 y (+.f64 z x))
(* x (+ 1 (+ (/ y x) (/ z x))))
(+.f64 y (+.f64 z x))
(* x (+ 1 (+ (/ y x) (/ z x))))
(+.f64 y (+.f64 z x))
x
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+.f64 y (+.f64 z x))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+.f64 y (+.f64 z x))
(* -1 (* x (- (* -1 (/ (+ y z) x)) 1)))
(+.f64 y (+.f64 z x))
(+ x z)
(+.f64 z x)
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
y
(* y (+ 1 (+ (/ x y) (/ z y))))
(+.f64 y (+.f64 z x))
(* y (+ 1 (+ (/ x y) (/ z y))))
(+.f64 y (+.f64 z x))
(* y (+ 1 (+ (/ x y) (/ z y))))
(+.f64 y (+.f64 z x))
y
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+.f64 y (+.f64 z x))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+.f64 y (+.f64 z x))
(* -1 (* y (- (* -1 (/ (+ x z) y)) 1)))
(+.f64 y (+.f64 z x))
(+ x y)
(+.f64 y x)
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
(+ x (+ y z))
(+.f64 y (+.f64 z x))
z
(* z (+ 1 (+ (/ x z) (/ y z))))
(+.f64 y (+.f64 z x))
(* z (+ 1 (+ (/ x z) (/ y z))))
(+.f64 y (+.f64 z x))
(* z (+ 1 (+ (/ x z) (/ y z))))
(+.f64 y (+.f64 z x))
z
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(+.f64 y (+.f64 z x))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(+.f64 y (+.f64 z x))
(* -1 (* z (- (* -1 (/ (+ x y) z)) 1)))
(+.f64 y (+.f64 z x))
z
(+ y z)
(+.f64 y z)
(+ y z)
(+.f64 y z)
(+ y z)
(+.f64 y z)
y
(* y (+ 1 (/ z y)))
(+.f64 y z)
(* y (+ 1 (/ z y)))
(+.f64 y z)
(* y (+ 1 (/ z y)))
(+.f64 y z)
y
(* -1 (* y (- (* -1 (/ z y)) 1)))
(+.f64 y z)
(* -1 (* y (- (* -1 (/ z y)) 1)))
(+.f64 y z)
(* -1 (* y (- (* -1 (/ z y)) 1)))
(+.f64 y z)
y
(+ y z)
(+.f64 y z)
(+ y z)
(+.f64 y z)
(+ y z)
(+.f64 y z)
z
(* z (+ 1 (/ y z)))
(+.f64 y z)
(* z (+ 1 (/ y z)))
(+.f64 y z)
(* z (+ 1 (/ y z)))
(+.f64 y z)
z
(* -1 (* z (- (* -1 (/ y z)) 1)))
(+.f64 y z)
(* -1 (* z (- (* -1 (/ y z)) 1)))
(+.f64 y z)
(* -1 (* z (- (* -1 (/ y z)) 1)))
(+.f64 y z)

rewrite207.0ms (4.5%)

Memory
31.7MiB live, 183.1MiB allocated
Rules
5 110×lower-*.f64
5 110×lower-*.f32
4 104×lower-fma.f64
4 104×lower-fma.f32
3 852×lower-/.f64
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
0827
01327
18617
296417
0844617
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
5 → 209
Calls
Call 1
Inputs
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
(+.f64 (+.f64 x y) z)
(+.f64 x y)
(+.f64 x (+.f64 y z))
(+.f64 y z)
Outputs
#s(literal 0 binary64)
(+.f64 x (+.f64 y z))
(+.f64 y (+.f64 x z))
(+.f64 y (+.f64 z x))
(+.f64 (+.f64 x y) z)
(+.f64 z (+.f64 x y))
(+.f64 (+.f64 y z) x)
(+.f64 (+.f64 x z) y)
(+.f64 (+.f64 z x) y)
(-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (/.f64 (*.f64 z z) (+.f64 x (-.f64 y z))))
(-.f64 (/.f64 (*.f64 x x) (-.f64 x (+.f64 y z))) (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 x (+.f64 y z))))
(-.f64 (/.f64 (*.f64 z z) (-.f64 z (+.f64 x y))) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 z (+.f64 x y))))
(-.f64 (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 (+.f64 y z) x)) (/.f64 (*.f64 x x) (-.f64 (+.f64 y z) x)))
(fma.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 y y (*.f64 z (-.f64 z y)))) x)
(fma.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 y z)))) x)
(fma.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (*.f64 x x))) z)
(fma.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y y (-.f64 (*.f64 x x) (*.f64 x y)))) z)
(fma.f64 (*.f64 (+.f64 y z) (-.f64 y z)) (/.f64 #s(literal 1 binary64) (-.f64 y z)) x)
(fma.f64 (*.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) z)
(fma.f64 (neg.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 y y (*.f64 z (-.f64 z y))))) x)
(fma.f64 (neg.f64 (*.f64 (+.f64 y z) (-.f64 y z))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 y z))) x)
(fma.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 y (-.f64 y x) (*.f64 x x)))) z)
(fma.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 x y))) z)
(fma.f64 #s(literal 1 binary64) (+.f64 x y) z)
(fma.f64 #s(literal 1 binary64) (+.f64 y z) x)
(fma.f64 (-.f64 (*.f64 z z) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (-.f64 z y)) x)
(fma.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) z)
(/.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z))) (fma.f64 z (-.f64 z (+.f64 x y)) (*.f64 (+.f64 x y) (+.f64 x y))))
(/.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z))) (fma.f64 z z (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))))
(/.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (fma.f64 x x (*.f64 (+.f64 y z) (-.f64 (+.f64 y z) x))))
(/.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (fma.f64 (+.f64 y z) (+.f64 y z) (-.f64 (*.f64 x x) (*.f64 x (+.f64 y z)))))
(/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z))) (+.f64 x (-.f64 y z)))
(/.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z))) (-.f64 x (+.f64 y z)))
(/.f64 (neg.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z)))) (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (*.f64 (+.f64 x y) (+.f64 x y)))))
(/.f64 (neg.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z)))) (neg.f64 (fma.f64 z z (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z)))))
(/.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))))) (neg.f64 (fma.f64 x x (*.f64 (+.f64 y z) (-.f64 (+.f64 y z) x)))))
(/.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))))) (neg.f64 (fma.f64 (+.f64 y z) (+.f64 y z) (-.f64 (*.f64 x x) (*.f64 x (+.f64 y z))))))
(/.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z)))) (neg.f64 (+.f64 x (-.f64 y z))))
(/.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z)))) (neg.f64 (-.f64 x (+.f64 y z))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 z z (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))) (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 y z) (+.f64 y z) (-.f64 (*.f64 x x) (*.f64 x (+.f64 y z)))) (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (+.f64 x y)) (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 y z) x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x x))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z)))))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (-.f64 z (+.f64 x y)))
(/.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x x)) (-.f64 (+.f64 y z) x))
(/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (*.f64 (+.f64 x (-.f64 y z)) (*.f64 z z))) (*.f64 (+.f64 x (-.f64 y z)) (+.f64 x (-.f64 y z))))
(/.f64 (-.f64 (*.f64 (*.f64 x x) (-.f64 x (+.f64 y z))) (*.f64 (-.f64 x (+.f64 y z)) (*.f64 (+.f64 y z) (+.f64 y z)))) (*.f64 (-.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z))))) (neg.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (*.f64 (+.f64 x y) (+.f64 x y))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))))) (neg.f64 (neg.f64 (fma.f64 x x (*.f64 (+.f64 y z) (-.f64 (+.f64 y z) x))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z))))) (neg.f64 (neg.f64 (+.f64 x (-.f64 y z)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z))))) (neg.f64 (neg.f64 (-.f64 x (+.f64 y z)))))
(/.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 z (+.f64 x y))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x x))) (neg.f64 (-.f64 (+.f64 y z) x)))
(/.f64 (fma.f64 y (*.f64 y y) (pow.f64 (+.f64 x z) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (*.f64 (+.f64 x z) (+.f64 x z)) (*.f64 y (+.f64 x z)))))
(/.f64 (fma.f64 y (*.f64 y y) (pow.f64 (+.f64 z x) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (*.f64 (+.f64 z x) (+.f64 z x)) (*.f64 y (+.f64 z x)))))
(/.f64 (+.f64 (pow.f64 (+.f64 x z) #s(literal 3 binary64)) (*.f64 y (*.f64 y y))) (fma.f64 (+.f64 x z) (+.f64 x z) (-.f64 (*.f64 y y) (*.f64 (+.f64 x z) y))))
(/.f64 (+.f64 (pow.f64 (+.f64 z x) #s(literal 3 binary64)) (*.f64 y (*.f64 y y))) (fma.f64 (+.f64 z x) (+.f64 z x) (-.f64 (*.f64 y y) (*.f64 (+.f64 z x) y))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 z z) (+.f64 x (-.f64 y z))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (fma.f64 (/.f64 (*.f64 z z) (+.f64 x (-.f64 y z))) (/.f64 (*.f64 z z) (+.f64 x (-.f64 y z))) (*.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (/.f64 (*.f64 z z) (+.f64 x (-.f64 y z)))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 x x) (-.f64 x (+.f64 y z))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 x (+.f64 y z))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 x x) (-.f64 x (+.f64 y z))) (/.f64 (*.f64 x x) (-.f64 x (+.f64 y z))) (fma.f64 (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 x (+.f64 y z))) (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 x (+.f64 y z))) (*.f64 (/.f64 (*.f64 x x) (-.f64 x (+.f64 y z))) (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 x (+.f64 y z)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))) #s(literal -1 binary64))
(*.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (*.f64 (+.f64 x y) (+.f64 x y)))))
(*.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z z (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z)))))
(*.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (*.f64 (+.f64 y z) (-.f64 (+.f64 y z) x)))))
(*.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 y z) (+.f64 y z) (-.f64 (*.f64 x x) (*.f64 x (+.f64 y z))))))
(*.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))))
(*.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 y z))))
(*.f64 (neg.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (*.f64 (+.f64 x y) (+.f64 x y))))))
(*.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 x x (*.f64 (+.f64 y z) (-.f64 (+.f64 y z) x))))))
(*.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (+.f64 x (-.f64 y z)))))
(*.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 x (+.f64 y z)))))
(*.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z)))
(*.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (-.f64 z (+.f64 x y))))
(*.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 y z) x)))
(+.f64 x y)
(+.f64 y x)
(-.f64 (/.f64 (*.f64 x x) (-.f64 x y)) (/.f64 (*.f64 y y) (-.f64 x y)))
(-.f64 (/.f64 (*.f64 y y) (-.f64 y x)) (/.f64 (*.f64 x x) (-.f64 y x)))
(/.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y))) (fma.f64 y (-.f64 y x) (*.f64 x x)))
(/.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y))) (fma.f64 y y (-.f64 (*.f64 x x) (*.f64 x y))))
(/.f64 (*.f64 (+.f64 x y) (-.f64 x y)) (-.f64 x y))
(/.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y)))) (neg.f64 (fma.f64 y (-.f64 y x) (*.f64 x x))))
(/.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y)))) (neg.f64 (fma.f64 y y (-.f64 (*.f64 x x) (*.f64 x y)))))
(/.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y))) (neg.f64 (-.f64 x y)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 x y)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 y y (-.f64 (*.f64 x x) (*.f64 x y))) (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 y x) (-.f64 (*.f64 y y) (*.f64 x x))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y))))
(/.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (-.f64 y x))
(/.f64 (-.f64 (*.f64 (*.f64 x x) (-.f64 x y)) (*.f64 (-.f64 x y) (*.f64 y y))) (*.f64 (-.f64 x y) (-.f64 x y)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y))))) (neg.f64 (neg.f64 (fma.f64 y (-.f64 y x) (*.f64 x x)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y)))) (neg.f64 (neg.f64 (-.f64 x y))))
(/.f64 (neg.f64 (-.f64 (*.f64 y y) (*.f64 x x))) (neg.f64 (-.f64 y x)))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 x x) (-.f64 x y)) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 y y) (-.f64 x y)) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 x x) (-.f64 x y)) (/.f64 (*.f64 x x) (-.f64 x y)) (fma.f64 (/.f64 (*.f64 y y) (-.f64 x y)) (/.f64 (*.f64 y y) (-.f64 x y)) (*.f64 (/.f64 (*.f64 x x) (-.f64 x y)) (/.f64 (*.f64 y y) (-.f64 x y))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 x y)) #s(literal -1 binary64))
(*.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (*.f64 x x))))
(*.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y y (-.f64 (*.f64 x x) (*.f64 x y)))))
(*.f64 (*.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)))
(*.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 y (-.f64 y x) (*.f64 x x)))))
(*.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 x y))))
(*.f64 #s(literal 1 binary64) (+.f64 x y))
(*.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)))
(+.f64 x (+.f64 y z))
(+.f64 y (+.f64 x z))
(+.f64 y (+.f64 z x))
(+.f64 (+.f64 x y) z)
(+.f64 z (+.f64 x y))
(+.f64 (+.f64 y z) x)
(+.f64 (+.f64 x z) y)
(+.f64 (+.f64 z x) y)
(-.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (/.f64 (*.f64 z z) (+.f64 x (-.f64 y z))))
(-.f64 (/.f64 (*.f64 x x) (-.f64 x (+.f64 y z))) (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 x (+.f64 y z))))
(-.f64 (/.f64 (*.f64 z z) (-.f64 z (+.f64 x y))) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (-.f64 z (+.f64 x y))))
(-.f64 (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 (+.f64 y z) x)) (/.f64 (*.f64 x x) (-.f64 (+.f64 y z) x)))
(fma.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 y y (*.f64 z (-.f64 z y)))) x)
(fma.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 y z)))) x)
(fma.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y (-.f64 y x) (*.f64 x x))) z)
(fma.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y))) (/.f64 #s(literal 1 binary64) (fma.f64 y y (-.f64 (*.f64 x x) (*.f64 x y)))) z)
(fma.f64 (*.f64 (+.f64 y z) (-.f64 y z)) (/.f64 #s(literal 1 binary64) (-.f64 y z)) x)
(fma.f64 (*.f64 (+.f64 x y) (-.f64 x y)) (/.f64 #s(literal 1 binary64) (-.f64 x y)) z)
(fma.f64 (neg.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 y y (*.f64 z (-.f64 z y))))) x)
(fma.f64 (neg.f64 (*.f64 (+.f64 y z) (-.f64 y z))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 y z))) x)
(fma.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 y (*.f64 y y)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 y (-.f64 y x) (*.f64 x x)))) z)
(fma.f64 (neg.f64 (*.f64 (+.f64 x y) (-.f64 x y))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 x y))) z)
(fma.f64 #s(literal 1 binary64) (+.f64 x y) z)
(fma.f64 #s(literal 1 binary64) (+.f64 y z) x)
(fma.f64 (-.f64 (*.f64 z z) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (-.f64 z y)) x)
(fma.f64 (-.f64 (*.f64 y y) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 y x)) z)
(/.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z))) (fma.f64 z (-.f64 z (+.f64 x y)) (*.f64 (+.f64 x y) (+.f64 x y))))
(/.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z))) (fma.f64 z z (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))))
(/.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (fma.f64 x x (*.f64 (+.f64 y z) (-.f64 (+.f64 y z) x))))
(/.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (fma.f64 (+.f64 y z) (+.f64 y z) (-.f64 (*.f64 x x) (*.f64 x (+.f64 y z)))))
(/.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z))) (+.f64 x (-.f64 y z)))
(/.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z))) (-.f64 x (+.f64 y z)))
(/.f64 (neg.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z)))) (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (*.f64 (+.f64 x y) (+.f64 x y)))))
(/.f64 (neg.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z)))) (neg.f64 (fma.f64 z z (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z)))))
(/.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))))) (neg.f64 (fma.f64 x x (*.f64 (+.f64 y z) (-.f64 (+.f64 y z) x)))))
(/.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))))) (neg.f64 (fma.f64 (+.f64 y z) (+.f64 y z) (-.f64 (*.f64 x x) (*.f64 x (+.f64 y z))))))
(/.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z)))) (neg.f64 (+.f64 x (-.f64 y z))))
(/.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z)))) (neg.f64 (-.f64 x (+.f64 y z))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 z z (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z))) (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 y z) (+.f64 y z) (-.f64 (*.f64 x x) (*.f64 x (+.f64 y z)))) (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z (+.f64 x y)) (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 y z) x) (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x x))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z)))))
(/.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (-.f64 z (+.f64 x y)))
(/.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x x)) (-.f64 (+.f64 y z) x))
(/.f64 (-.f64 (*.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (*.f64 (+.f64 x (-.f64 y z)) (*.f64 z z))) (*.f64 (+.f64 x (-.f64 y z)) (+.f64 x (-.f64 y z))))
(/.f64 (-.f64 (*.f64 (*.f64 x x) (-.f64 x (+.f64 y z))) (*.f64 (-.f64 x (+.f64 y z)) (*.f64 (+.f64 y z) (+.f64 y z)))) (*.f64 (-.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z))))) (neg.f64 (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (*.f64 (+.f64 x y) (+.f64 x y))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))))) (neg.f64 (neg.f64 (fma.f64 x x (*.f64 (+.f64 y z) (-.f64 (+.f64 y z) x))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z))))) (neg.f64 (neg.f64 (+.f64 x (-.f64 y z)))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z))))) (neg.f64 (neg.f64 (-.f64 x (+.f64 y z)))))
(/.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y)))) (neg.f64 (-.f64 z (+.f64 x y))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x x))) (neg.f64 (-.f64 (+.f64 y z) x)))
(/.f64 (fma.f64 y (*.f64 y y) (pow.f64 (+.f64 x z) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (*.f64 (+.f64 x z) (+.f64 x z)) (*.f64 y (+.f64 x z)))))
(/.f64 (fma.f64 y (*.f64 y y) (pow.f64 (+.f64 z x) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (*.f64 (+.f64 z x) (+.f64 z x)) (*.f64 y (+.f64 z x)))))
(/.f64 (+.f64 (pow.f64 (+.f64 x z) #s(literal 3 binary64)) (*.f64 y (*.f64 y y))) (fma.f64 (+.f64 x z) (+.f64 x z) (-.f64 (*.f64 y y) (*.f64 (+.f64 x z) y))))
(/.f64 (+.f64 (pow.f64 (+.f64 z x) #s(literal 3 binary64)) (*.f64 y (*.f64 y y))) (fma.f64 (+.f64 z x) (+.f64 z x) (-.f64 (*.f64 y y) (*.f64 (+.f64 z x) y))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 z z) (+.f64 x (-.f64 y z))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (fma.f64 (/.f64 (*.f64 z z) (+.f64 x (-.f64 y z))) (/.f64 (*.f64 z z) (+.f64 x (-.f64 y z))) (*.f64 (/.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (+.f64 x (-.f64 y z))) (/.f64 (*.f64 z z) (+.f64 x (-.f64 y z)))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 x x) (-.f64 x (+.f64 y z))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 x (+.f64 y z))) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 x x) (-.f64 x (+.f64 y z))) (/.f64 (*.f64 x x) (-.f64 x (+.f64 y z))) (fma.f64 (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 x (+.f64 y z))) (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 x (+.f64 y z))) (*.f64 (/.f64 (*.f64 x x) (-.f64 x (+.f64 y z))) (/.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (-.f64 x (+.f64 y z)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z))) #s(literal -1 binary64))
(*.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (+.f64 x y)) (*.f64 (+.f64 x y) (+.f64 x y)))))
(*.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z z (-.f64 (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 (+.f64 x y) z)))))
(*.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (fma.f64 x x (*.f64 (+.f64 y z) (-.f64 (+.f64 y z) x)))))
(*.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 y z) (+.f64 y z) (-.f64 (*.f64 x x) (*.f64 x (+.f64 y z))))))
(*.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z))) (/.f64 #s(literal 1 binary64) (+.f64 x (-.f64 y z))))
(*.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z))) (/.f64 #s(literal 1 binary64) (-.f64 x (+.f64 y z))))
(*.f64 (neg.f64 (fma.f64 (+.f64 x y) (*.f64 (+.f64 x y) (+.f64 x y)) (*.f64 z (*.f64 z z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 z (-.f64 z (+.f64 x y)) (*.f64 (+.f64 x y) (+.f64 x y))))))
(*.f64 (neg.f64 (fma.f64 x (*.f64 x x) (*.f64 (+.f64 y z) (*.f64 (+.f64 y z) (+.f64 y z))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 x x (*.f64 (+.f64 y z) (-.f64 (+.f64 y z) x))))))
(*.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (+.f64 x (-.f64 y z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (+.f64 x (-.f64 y z)))))
(*.f64 (neg.f64 (*.f64 (+.f64 x (+.f64 y z)) (-.f64 x (+.f64 y z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 x (+.f64 y z)))))
(*.f64 #s(literal 1 binary64) (+.f64 x (+.f64 y z)))
(*.f64 (-.f64 (*.f64 z z) (*.f64 (+.f64 x y) (+.f64 x y))) (/.f64 #s(literal 1 binary64) (-.f64 z (+.f64 x y))))
(*.f64 (-.f64 (*.f64 (+.f64 y z) (+.f64 y z)) (*.f64 x x)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 y z) x)))
(+.f64 y z)
(+.f64 z y)
(-.f64 (/.f64 (*.f64 y y) (-.f64 y z)) (/.f64 (*.f64 z z) (-.f64 y z)))
(-.f64 (/.f64 (*.f64 z z) (-.f64 z y)) (/.f64 (*.f64 y y) (-.f64 z y)))
(/.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z))) (fma.f64 y y (*.f64 z (-.f64 z y))))
(/.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z))) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 y z))))
(/.f64 (*.f64 (+.f64 y z) (-.f64 y z)) (-.f64 y z))
(/.f64 (neg.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z)))) (neg.f64 (fma.f64 y y (*.f64 z (-.f64 z y)))))
(/.f64 (neg.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z)))) (neg.f64 (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 y z)))))
(/.f64 (neg.f64 (*.f64 (+.f64 y z) (-.f64 y z))) (neg.f64 (-.f64 y z)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 y z)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 y z))) (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 y z)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 z y) (-.f64 (*.f64 z z) (*.f64 y y))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 y z))))
(/.f64 (-.f64 (*.f64 z z) (*.f64 y y)) (-.f64 z y))
(/.f64 (-.f64 (*.f64 (*.f64 y y) (-.f64 y z)) (*.f64 (-.f64 y z) (*.f64 z z))) (*.f64 (-.f64 y z) (-.f64 y z)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z))))) (neg.f64 (neg.f64 (fma.f64 y y (*.f64 z (-.f64 z y))))))
(/.f64 (neg.f64 (neg.f64 (*.f64 (+.f64 y z) (-.f64 y z)))) (neg.f64 (neg.f64 (-.f64 y z))))
(/.f64 (neg.f64 (-.f64 (*.f64 z z) (*.f64 y y))) (neg.f64 (-.f64 z y)))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 y y) (-.f64 y z)) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 z z) (-.f64 y z)) #s(literal 3 binary64))) (fma.f64 (/.f64 (*.f64 y y) (-.f64 y z)) (/.f64 (*.f64 y y) (-.f64 y z)) (fma.f64 (/.f64 (*.f64 z z) (-.f64 y z)) (/.f64 (*.f64 z z) (-.f64 y z)) (*.f64 (/.f64 (*.f64 y y) (-.f64 y z)) (/.f64 (*.f64 z z) (-.f64 y z))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 y z)) #s(literal -1 binary64))
(*.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 y y (*.f64 z (-.f64 z y)))))
(*.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 z z (-.f64 (*.f64 y y) (*.f64 y z)))))
(*.f64 (*.f64 (+.f64 y z) (-.f64 y z)) (/.f64 #s(literal 1 binary64) (-.f64 y z)))
(*.f64 (neg.f64 (fma.f64 y (*.f64 y y) (*.f64 z (*.f64 z z)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 y y (*.f64 z (-.f64 z y))))))
(*.f64 (neg.f64 (*.f64 (+.f64 y z) (-.f64 y z))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 y z))))
(*.f64 #s(literal 1 binary64) (+.f64 y z))
(*.f64 (-.f64 (*.f64 z z) (*.f64 y y)) (/.f64 #s(literal 1 binary64) (-.f64 z y)))

eval33.0ms (0.7%)

Memory
-23.6MiB live, 49.1MiB allocated
Compiler

Compiled 6 996 to 616 computations (91.2% saved)

prune71.0ms (1.5%)

Memory
-7.7MiB live, 54.6MiB allocated
Pruning

1 alts after pruning (1 fresh and 0 done)

PrunedKeptTotal
New3401341
Fresh000
Picked101
Done000
Total3411342
Accuracy
100.0%
Counts
342 → 1
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶100.0%
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))
Compiler

Compiled 5 to 4 computations (20% saved)

simplify370.0ms (8%)

Memory
26.7MiB live, 152.6MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 1 expressions of interest:

NewMetricScoreProgram
cost-diff0
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))
Rules
14 508×lower-fma.f64
14 508×lower-fma.f32
3 456×unsub-neg
2 832×lower-+.f64
2 832×lower-+.f32
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
01014
01024
1224
2864
33534
411764
518194
638814
750154
858424
962964
1063304
1163344
1264524
1364614
1464624
1564624
1664624
1773114
1874634
1976154
2077294
2177674
2277674
081514
Stop Event
1×iter limit
1×node limit
1×saturated
Calls
Call 1
Inputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))
#s(literal 0 binary64)
Outputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))
#s(literal 0 binary64)

localize74.0ms (1.6%)

Memory
-23.2MiB live, 51.9MiB allocated
Localize:

Found 1 expressions of interest:

NewMetricScoreProgram
accuracy0
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))
Samples
47.0ms121×1valid
20.0ms134×2valid
0.0ms1×0valid
Compiler

Compiled 14 to 11 computations (21.4% saved)

Precisions
Click to see histograms. Total time spent on operations: 54.0ms
ival-add: 41.0ms (75.9% of total)
adjust: 10.0ms (18.5% of total)
ival-sub: 2.0ms (3.7% of total)
ival-assert: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

series1.0ms (0%)

Memory
0.9MiB live, 0.9MiB allocated
Counts
1 → 36
Calls
Call 1
Inputs
#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())
Outputs
#s(alt 0 (taylor 0 x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf x) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf y) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor 0 z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
#s(alt 0 (taylor -inf z) (#s(alt #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) (patch #s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64)) #<representation binary64>) () ())) ())
Calls

9 calls:

TimeVariablePointExpression
0.0ms
x
@0
(- (+ (+ x y) z) (+ x (+ y z)))
0.0ms
x
@inf
(- (+ (+ x y) z) (+ x (+ y z)))
0.0ms
x
@-inf
(- (+ (+ x y) z) (+ x (+ y z)))
0.0ms
y
@inf
(- (+ (+ x y) z) (+ x (+ y z)))
0.0ms
y
@-inf
(- (+ (+ x y) z) (+ x (+ y z)))

simplify3.0ms (0.1%)

Memory
1.2MiB live, 1.2MiB allocated
Algorithm
1×egg-herbie
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0136
0136
Stop Event
1×saturated
1×saturated
Counts
36 → 36
Calls
Call 1
Inputs
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
Outputs
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)
0
#s(literal 0 binary64)

rewrite246.0ms (5.3%)

Memory
17.1MiB live, 137.7MiB allocated
Rules
5 110×lower-*.f64
5 110×lower-*.f32
4 104×lower-fma.f64
4 104×lower-fma.f32
3 852×lower-/.f64
Iterations

Useful iterations: 1 (0.0ms)

IterNodesCost
01013
01013
1823
29593
084413
Stop Event
1×iter limit
1×node limit
1×saturated
Counts
1 → 1
Calls
Call 1
Inputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))
Outputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))

eval2.0ms (0.1%)

Memory
2.3MiB live, 2.3MiB allocated
Compiler

Compiled 77 to 4 computations (94.8% saved)

prune1.0ms (0%)

Memory
1.0MiB live, 1.0MiB allocated
Pruning

1 alts after pruning (0 fresh and 1 done)

PrunedKeptTotal
New37037
Fresh000
Picked011
Done000
Total37138
Accuracy
100.0%
Counts
38 → 1
Alt Table
Click to see full alt table
StatusAccuracyProgram
✓100.0%
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))
Compiler

Compiled 21 to 13 computations (38.1% saved)

regimes9.0ms (0.2%)

Memory
-25.0MiB live, 6.1MiB allocated
Accuracy

Total -0.1b remaining (-∞%)

Threshold costs -0.1b (-∞%)

Counts
2 → 1
Calls
Call 1
Inputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
Outputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))
Calls

4 calls:

5.0ms
z
1.0ms
y
1.0ms
x
1.0ms
(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
Results
AccuracySegmentsBranch
100.0%1x
100.0%1y
100.0%1z
100.0%1(-.f64 (+.f64 (+.f64 x y) z) (+.f64 x (+.f64 y z)))
Compiler

Compiled 26 to 17 computations (34.6% saved)

simplify5.0ms (0.1%)

Memory
4.0MiB live, 4.0MiB allocated
Algorithm
1×egg-herbie
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01013
Stop Event
1×saturated
Calls
Call 1
Inputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))
Outputs
#s(approx (- (+ (+ x y) z) (+ x (+ y z))) #s(literal 0 binary64))

soundness322.0ms (7%)

Memory
2.0MiB live, 2.0MiB allocated
Rules
15 312×lower-fma.f64
15 312×lower-fma.f32
5 296×lower-/.f32
5 296×lower-/.f64
2 424×lower-*.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
064456
1188456
2477456
31435456
43496456
54400456
64902456
75035456
85053456
95053456
08893456
Stop Event
1×done
1×iter limit
1×node limit
Compiler

Compiled 9 to 8 computations (11.1% saved)

preprocess89.0ms (1.9%)

Memory
9.4MiB live, 39.7MiB allocated
Remove

(sort x y z)

(negabs x)

(negabs y)

(negabs z)

(abs x)

(abs y)

(abs z)

Compiler

Compiled 108 to 80 computations (25.9% saved)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...