Metrics for FastMath test3

analyze0.0ms (0%)

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 15 to 10 computations (33.3% saved)

Precisions

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

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

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

const: 0.0ms (0% of total)

backward-pass: 0.0ms (0% of total)

sample968.0ms (26.8%)

Results

629.0ms	7803×	0	valid
89.0ms	360×	1	valid
28.0ms	93×	2	valid

Precisions

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

ival-mult: 229.0ms (66.3% of total)

ival-add: 86.0ms (24.9% of total)

backward-pass: 20.0ms (5.8% of total)

const: 11.0ms (3.2% of total)

Bogosity

preprocess82.0ms (2.3%)

Algorithm

2×	egg-herbie

Rules

2740×	`sum3-define`
1368×	`fnmadd-define`
1236×	`sum4-define`
1078×	`fma-define`
1046×	`sum5-define`

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	37	98
1	136	74
2	449	66
3	1648	65
4	6380	65
5	7875	65
0	9	9
1	20	7
2	47	6
3	79	6
4	94	6
5	96	6
0	96	6

Stop Event

1×	iter limit
1×	saturated
1×	node limit

Calls

Call 1

Inputs
(+ (+ (* d1 3) (* d1 d2)) (* d1 d3))

Outputs
(+ (+ (* d1 3) (* d1 d2)) (* d1 d3))
(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))

Call 2

Inputs
(+ (+ (* d1 3) (* d1 d2)) (* d1 d3))
(+ (+ (* (neg d1) 3) (* (neg d1) d2)) (* (neg d1) d3))
(+ (+ (* d1 3) (* d1 (neg d2))) (* d1 d3))
(+ (+ (* d1 3) (* d1 d2)) (* d1 (neg d3)))
(neg (+ (+ (* (neg d1) 3) (* (neg d1) d2)) (* (neg d1) d3)))
(neg (+ (+ (* d1 3) (* d1 (neg d2))) (* d1 d3)))
(neg (+ (+ (* d1 3) (* d1 d2)) (* d1 (neg d3))))
(+ (+ (* d2 3) (* d2 d1)) (* d2 d3))
(+ (+ (* d3 3) (* d3 d2)) (* d3 d1))
(+ (+ (* d1 3) (* d1 d3)) (* d1 d2))

Outputs
(+ (+ (* d1 3) (* d1 d2)) (* d1 d3))
(* d1 (sum3 3 d2 d3))
(+ (+ (* (neg d1) 3) (* (neg d1) d2)) (* (neg d1) d3))
(* d1 (- -3 (+ d2 d3)))
(+ (+ (* d1 3) (* d1 (neg d2))) (* d1 d3))
(* d1 (+ 3 (- d3 d2)))
(+ (+ (* d1 3) (* d1 d2)) (* d1 (neg d3)))
(* d1 (+ d2 (- 3 d3)))
(neg (+ (+ (* (neg d1) 3) (* (neg d1) d2)) (* (neg d1) d3)))
(* d1 (sum3 3 d2 d3))
(neg (+ (+ (* d1 3) (* d1 (neg d2))) (* d1 d3)))
(* d1 (+ d2 (- -3 d3)))
(neg (+ (+ (* d1 3) (* d1 d2)) (* d1 (neg d3))))
(* d1 (+ d3 (- -3 d2)))
(+ (+ (* d2 3) (* d2 d1)) (* d2 d3))
(* d2 (sum3 d1 3 d3))
(+ (+ (* d3 3) (* d3 d2)) (* d3 d1))
(* d3 (sum3 d1 3 d2))
(+ (+ (* d1 3) (* d1 d3)) (* d1 d2))
(* d1 (sum3 3 d2 d3))

Symmetry

(negabs d1)

(sort d2 d3)

explain117.0ms (3.2%)

FPErrors

Click to see full error table

Ground Truth	Example	Example	Subexpression
6	-	-	`(+.f64 (+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d2)) (*.f64 d1 d3))`
0	-	-	`d3`
0	-	-	`d1`
0	-	-	`d2`
0	-	-	`(*.f64 d1 d3)`
0	-	-	`(*.f64 d1 d2)`
0	-	-	`#s(literal 3 binary64)`
0	-	-	`(+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d2))`
0	-	-	`(*.f64 d1 #s(literal 3 binary64))`

Results

60.0ms	450×	0	valid
8.0ms	36×	1	valid
8.0ms	24×	2	valid
1.0ms	2×	3	valid

Compiler

Compiled 84 to 29 computations (65.5% saved)

Precisions

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

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

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

backward-pass: 2.0ms (9.2% of total)

const: 1.0ms (4.6% of total)

eval0.0ms (0%)

Compiler: Compiled 10 to 7 computations (30% saved)

prune1.0ms (0%)

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	97.5%	(+.f64 (+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d2)) (*.f64 d1 d3))
▶	99.9%	(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))

Compiler

Compiled 24 to 16 computations (33.3% saved)

simplify8.0ms (0.2%)

Algorithm

1×	egg-herbie

Localize:

Found 7 expressions of interest:

New	Metric	Score	Program
✓	cost-diff	0	(*.f64 d1 d2)
✓	cost-diff	0	(*.f64 d1 #s(literal 3 binary64))
✓	cost-diff	128	(+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d2))
✓	cost-diff	256	(+.f64 (+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d2)) (*.f64 d1 d3))
✓	cost-diff	0	(+.f64 #s(literal 3 binary64) d3)
✓	cost-diff	0	(+.f64 d2 (+.f64 #s(literal 3 binary64) d3))
✓	cost-diff	0	(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))

Rules

52×	`fma-define`
48×	`fma-lowering-fma.f32`
48×	`+-lowering-+.f64`
48×	`+-lowering-+.f32`
48×	`fma-lowering-fma.f64`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	12	44
1	33	41
2	73	41
3	98	41
4	100	41
0	100	41

Stop Event

1×	iter limit
1×	saturated

Calls

Call 1

Inputs
(* d1 (+ d2 (+ 3 d3)))
d1
(+ d2 (+ 3 d3))
d2
(+ 3 d3)
3
d3
(+ (+ (* d1 3) (* d1 d2)) (* d1 d3))
(+ (* d1 3) (* d1 d2))
(* d1 3)
d1
3
(* d1 d2)
d2
(* d1 d3)
d3

Outputs
(* d1 (+ d2 (+ 3 d3)))
(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))
d1
(+ d2 (+ 3 d3))
(+.f64 d2 (+.f64 #s(literal 3 binary64) d3))
d2
(+ 3 d3)
(+.f64 #s(literal 3 binary64) d3)
3
#s(literal 3 binary64)
d3
(+ (+ (* d1 3) (* d1 d2)) (* d1 d3))
(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))
(+ (* d1 3) (* d1 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 3)
(*.f64 d1 #s(literal 3 binary64))
d1
3
#s(literal 3 binary64)
(* d1 d2)
(*.f64 d1 d2)
d2
(* d1 d3)
(*.f64 d1 d3)
d3

localize165.0ms (4.6%)

Localize:

Found 7 expressions of interest:

New	Metric	Score	Program
✓	accuracy	100.0%	(*.f64 d1 d2)
✓	accuracy	100.0%	(*.f64 d1 #s(literal 3 binary64))
✓	accuracy	99.8%	(+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d2))
✓	accuracy	97.8%	(+.f64 (+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d2)) (*.f64 d1 d3))
✓	accuracy	100.0%	(+.f64 #s(literal 3 binary64) d3)
✓	accuracy	100.0%	(+.f64 d2 (+.f64 #s(literal 3 binary64) d3))
✓	accuracy	99.9%	(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))

Results

138.0ms	224×	0	valid
6.0ms	13×	2	valid
6.0ms	18×	1	valid
1.0ms	1×	3	valid

Compiler

Compiled 54 to 13 computations (75.9% saved)

Precisions

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

ival-add: 108.0ms (90.9% of total)

ival-mult: 9.0ms (7.6% of total)

backward-pass: 2.0ms (1.7% of total)

const: 0.0ms (0% of total)

series111.0ms (3.1%)

Counts

7 → 168

Calls

Call 1

Inputs
#<alt (* d1 (+ d2 (+ 3 d3)))>
#<alt (+ d2 (+ 3 d3))>
#<alt (+ 3 d3)>
#<alt (+ (+ (* d1 3) (* d1 d2)) (* d1 d3))>
#<alt (+ (* d1 3) (* d1 d2))>
#<alt (* d1 3)>
#<alt (* d1 d2)>

Outputs
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 d3))>
#<alt (+ (* d1 d2) (* d1 (+ 3 d3)))>
#<alt (+ (* d1 d2) (* d1 (+ 3 d3)))>
#<alt (+ (* d1 d2) (* d1 (+ 3 d3)))>
#<alt (* d1 d2)>
#<alt (* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))>
#<alt (* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))>
#<alt (* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))>
#<alt (* d1 d2)>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))>
#<alt (* d1 (+ 3 d2))>
#<alt (+ (* d1 d3) (* d1 (+ 3 d2)))>
#<alt (+ (* d1 d3) (* d1 (+ 3 d2)))>
#<alt (+ (* d1 d3) (* d1 (+ 3 d2)))>
#<alt (* d1 d3)>
#<alt (* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))>
#<alt (* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))>
#<alt (* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))>
#<alt (* d1 d3)>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))>
#<alt (+ 3 d3)>
#<alt (+ 3 (+ d2 d3))>
#<alt (+ 3 (+ d2 d3))>
#<alt (+ 3 (+ d2 d3))>
#<alt d2>
#<alt (* d2 (+ 1 (+ (* 3 (/ 1 d2)) (/ d3 d2))))>
#<alt (* d2 (+ 1 (+ (* 3 (/ 1 d2)) (/ d3 d2))))>
#<alt (* d2 (+ 1 (+ (* 3 (/ 1 d2)) (/ d3 d2))))>
#<alt d2>
#<alt (* -1 (* d2 (- (* -1 (/ (+ 3 d3) d2)) 1)))>
#<alt (* -1 (* d2 (- (* -1 (/ (+ 3 d3) d2)) 1)))>
#<alt (* -1 (* d2 (- (* -1 (/ (+ 3 d3) d2)) 1)))>
#<alt (+ 3 d2)>
#<alt (+ 3 (+ d2 d3))>
#<alt (+ 3 (+ d2 d3))>
#<alt (+ 3 (+ d2 d3))>
#<alt d3>
#<alt (* d3 (+ 1 (+ (* 3 (/ 1 d3)) (/ d2 d3))))>
#<alt (* d3 (+ 1 (+ (* 3 (/ 1 d3)) (/ d2 d3))))>
#<alt (* d3 (+ 1 (+ (* 3 (/ 1 d3)) (/ d2 d3))))>
#<alt d3>
#<alt (* -1 (* d3 (- (* -1 (/ (+ 3 d2) d3)) 1)))>
#<alt (* -1 (* d3 (- (* -1 (/ (+ 3 d2) d3)) 1)))>
#<alt (* -1 (* d3 (- (* -1 (/ (+ 3 d2) d3)) 1)))>
#<alt 3>
#<alt (+ 3 d3)>
#<alt (+ 3 d3)>
#<alt (+ 3 d3)>
#<alt d3>
#<alt (* d3 (+ 1 (* 3 (/ 1 d3))))>
#<alt (* d3 (+ 1 (* 3 (/ 1 d3))))>
#<alt (* d3 (+ 1 (* 3 (/ 1 d3))))>
#<alt d3>
#<alt (* d3 (+ 1 (* 3 (/ 1 d3))))>
#<alt (* d3 (+ 1 (* 3 (/ 1 d3))))>
#<alt (* d3 (+ 1 (* 3 (/ 1 d3))))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* -1 (* d1 (- (+ (* -1 d2) (* -1 d3)) 3)))>
#<alt (* -1 (* d1 (- (+ (* -1 d2) (* -1 d3)) 3)))>
#<alt (* -1 (* d1 (- (+ (* -1 d2) (* -1 d3)) 3)))>
#<alt (* -1 (* d1 (- (+ (* -1 d2) (* -1 d3)) 3)))>
#<alt (+ (* 3 d1) (* d1 d3))>
#<alt (+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))>
#<alt (+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))>
#<alt (+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))>
#<alt (* d1 d2)>
#<alt (* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))>
#<alt (* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))>
#<alt (* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))>
#<alt (* d1 d2)>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))>
#<alt (+ (* 3 d1) (* d1 d2))>
#<alt (+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))>
#<alt (+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))>
#<alt (+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))>
#<alt (* d1 d3)>
#<alt (* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))>
#<alt (* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))>
#<alt (* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))>
#<alt (* d1 d3)>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* -1 (* d1 (- (* -1 d2) 3)))>
#<alt (* -1 (* d1 (- (* -1 d2) 3)))>
#<alt (* -1 (* d1 (- (* -1 d2) 3)))>
#<alt (* -1 (* d1 (- (* -1 d2) 3)))>
#<alt (* 3 d1)>
#<alt (+ (* 3 d1) (* d1 d2))>
#<alt (+ (* 3 d1) (* d1 d2))>
#<alt (+ (* 3 d1) (* d1 d2))>
#<alt (* d1 d2)>
#<alt (* d2 (+ d1 (* 3 (/ d1 d2))))>
#<alt (* d2 (+ d1 (* 3 (/ d1 d2))))>
#<alt (* d2 (+ d1 (* 3 (/ d1 d2))))>
#<alt (* d1 d2)>
#<alt (* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))>
#<alt (* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))>
#<alt (* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>

Calls

42 calls:

Time	Variable		Point	Expression
101.0ms	d1	@	-inf	(* d1 3)
1.0ms	d1	@	0	(+ (+ (* d1 3) (* d1 d2)) (* d1 d3))
1.0ms	d1	@	inf	(+ (+ (* d1 3) (* d1 d2)) (* d1 d3))
0.0ms	d1	@	0	(* d1 (+ d2 (+ 3 d3)))
0.0ms	d2	@	-inf	(* d1 (+ d2 (+ 3 d3)))

rewrite27.0ms (0.7%)

Algorithm

1×	batch-egg-rewrite

Rules

52×	`fma-define`
48×	`fma-lowering-fma.f32`
48×	`+-lowering-+.f64`
48×	`+-lowering-+.f32`
48×	`fma-lowering-fma.f64`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	12	33
1	33	30
2	73	30
3	98	30
4	100	30
0	100	30

Stop Event

1×	iter limit
1×	saturated

Counts

7 → 60

Calls

Call 1

Inputs
(* d1 (+ d2 (+ 3 d3)))
(+ d2 (+ 3 d3))
(+ 3 d3)
(+ (+ (* d1 3) (* d1 d2)) (* d1 d3))
(+ (* d1 3) (* d1 d2))
(* d1 3)
(* d1 d2)

Outputs
(+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 (+.f64 d2 d3)))
(+.f64 (.f64 d1 d2) (.f64 d1 (+.f64 #s(literal 3 binary64) d3)))
(+.f64 (.f64 d1 (+.f64 d2 #s(literal 3 binary64))) (.f64 d1 d3))
(+.f64 (.f64 d1 d3) (.f64 d1 (+.f64 d2 #s(literal 3 binary64))))
(+.f64 (.f64 d1 (+.f64 #s(literal 3 binary64) d3)) (.f64 d1 d2))
(+.f64 (.f64 d1 (+.f64 d2 d3)) (.f64 d1 #s(literal 3 binary64)))
(fma.f64 d1 d2 (*.f64 d1 (+.f64 #s(literal 3 binary64) d3)))
(fma.f64 d1 #s(literal 3 binary64) (*.f64 d1 (+.f64 d2 d3)))
(fma.f64 d1 d3 (*.f64 d1 (+.f64 d2 #s(literal 3 binary64))))
(fma.f64 d1 (+.f64 #s(literal 3 binary64) d3) (*.f64 d1 d2))
(fma.f64 d1 (+.f64 d2 #s(literal 3 binary64)) (*.f64 d1 d3))
(fma.f64 d1 (+.f64 d2 d3) (*.f64 d1 #s(literal 3 binary64)))
(fma.f64 d2 d1 (*.f64 d1 (+.f64 #s(literal 3 binary64) d3)))
(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 (+.f64 d2 d3)))
(fma.f64 d3 d1 (*.f64 d1 (+.f64 d2 #s(literal 3 binary64))))
(fma.f64 (+.f64 #s(literal 3 binary64) d3) d1 (*.f64 d1 d2))
(fma.f64 (+.f64 d2 #s(literal 3 binary64)) d1 (*.f64 d1 d3))
(fma.f64 (+.f64 d2 d3) d1 (*.f64 d1 #s(literal 3 binary64)))
(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))
(*.f64 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)) d1)
(+.f64 d2 (+.f64 #s(literal 3 binary64) d3))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(+.f64 d3 (+.f64 d2 #s(literal 3 binary64)))
(+.f64 (+.f64 #s(literal 3 binary64) d3) d2)
(+.f64 (+.f64 d2 #s(literal 3 binary64)) d3)
(+.f64 (+.f64 d2 d3) #s(literal 3 binary64))
(+.f64 #s(literal 3 binary64) d3)
(+.f64 d3 #s(literal 3 binary64))
(+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 (+.f64 d2 d3)))
(+.f64 (.f64 d1 d2) (.f64 d1 (+.f64 #s(literal 3 binary64) d3)))
(+.f64 (.f64 d1 (+.f64 d2 #s(literal 3 binary64))) (.f64 d1 d3))
(+.f64 (.f64 d1 d3) (.f64 d1 (+.f64 d2 #s(literal 3 binary64))))
(+.f64 (.f64 d1 (+.f64 #s(literal 3 binary64) d3)) (.f64 d1 d2))
(+.f64 (.f64 d1 (+.f64 d2 d3)) (.f64 d1 #s(literal 3 binary64)))
(fma.f64 d1 d2 (*.f64 d1 (+.f64 #s(literal 3 binary64) d3)))
(fma.f64 d1 #s(literal 3 binary64) (*.f64 d1 (+.f64 d2 d3)))
(fma.f64 d1 d3 (*.f64 d1 (+.f64 d2 #s(literal 3 binary64))))
(fma.f64 d1 (+.f64 #s(literal 3 binary64) d3) (*.f64 d1 d2))
(fma.f64 d1 (+.f64 d2 #s(literal 3 binary64)) (*.f64 d1 d3))
(fma.f64 d1 (+.f64 d2 d3) (*.f64 d1 #s(literal 3 binary64)))
(fma.f64 d2 d1 (*.f64 d1 (+.f64 #s(literal 3 binary64) d3)))
(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 (+.f64 d2 d3)))
(fma.f64 d3 d1 (*.f64 d1 (+.f64 d2 #s(literal 3 binary64))))
(fma.f64 (+.f64 #s(literal 3 binary64) d3) d1 (*.f64 d1 d2))
(fma.f64 (+.f64 d2 #s(literal 3 binary64)) d1 (*.f64 d1 d3))
(fma.f64 (+.f64 d2 d3) d1 (*.f64 d1 #s(literal 3 binary64)))
(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))
(*.f64 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)) d1)
(+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d2))
(+.f64 (.f64 d1 d2) (.f64 d1 #s(literal 3 binary64)))
(fma.f64 d1 d2 (*.f64 d1 #s(literal 3 binary64)))
(fma.f64 d1 #s(literal 3 binary64) (*.f64 d1 d2))
(fma.f64 d2 d1 (*.f64 d1 #s(literal 3 binary64)))
(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(*.f64 (+.f64 d2 #s(literal 3 binary64)) d1)
(*.f64 d1 #s(literal 3 binary64))
(*.f64 #s(literal 3 binary64) d1)
(*.f64 d1 d2)
(*.f64 d2 d1)

simplify160.0ms (4.4%)

Algorithm

1×	egg-herbie

Rules

2330×	`-lowering-.f32`
2330×	`-lowering-.f64`
1732×	`fnmadd-define`
1378×	`sum5-define`
1040×	`+-lowering-+.f64`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	99	816
1	349	738
2	936	738
3	2944	738
4	7981	738
0	8670	738

Stop Event

1×	iter limit
1×	node limit

Counts

168 → 168

Calls

Call 1

Inputs
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 d3))
(+ (* d1 d2) (* d1 (+ 3 d3)))
(+ (* d1 d2) (* d1 (+ 3 d3)))
(+ (* d1 d2) (* d1 (+ 3 d3)))
(* d1 d2)
(* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))
(* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))
(* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))
(* d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))
(* d1 (+ 3 d2))
(+ (* d1 d3) (* d1 (+ 3 d2)))
(+ (* d1 d3) (* d1 (+ 3 d2)))
(+ (* d1 d3) (* d1 (+ 3 d2)))
(* d1 d3)
(* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))
(* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))
(* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))
(* d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))
(+ 3 d3)
(+ 3 (+ d2 d3))
(+ 3 (+ d2 d3))
(+ 3 (+ d2 d3))
d2
(* d2 (+ 1 (+ (* 3 (/ 1 d2)) (/ d3 d2))))
(* d2 (+ 1 (+ (* 3 (/ 1 d2)) (/ d3 d2))))
(* d2 (+ 1 (+ (* 3 (/ 1 d2)) (/ d3 d2))))
d2
(* -1 (* d2 (- (* -1 (/ (+ 3 d3) d2)) 1)))
(* -1 (* d2 (- (* -1 (/ (+ 3 d3) d2)) 1)))
(* -1 (* d2 (- (* -1 (/ (+ 3 d3) d2)) 1)))
(+ 3 d2)
(+ 3 (+ d2 d3))
(+ 3 (+ d2 d3))
(+ 3 (+ d2 d3))
d3
(* d3 (+ 1 (+ (* 3 (/ 1 d3)) (/ d2 d3))))
(* d3 (+ 1 (+ (* 3 (/ 1 d3)) (/ d2 d3))))
(* d3 (+ 1 (+ (* 3 (/ 1 d3)) (/ d2 d3))))
d3
(* -1 (* d3 (- (* -1 (/ (+ 3 d2) d3)) 1)))
(* -1 (* d3 (- (* -1 (/ (+ 3 d2) d3)) 1)))
(* -1 (* d3 (- (* -1 (/ (+ 3 d2) d3)) 1)))
3
(+ 3 d3)
(+ 3 d3)
(+ 3 d3)
d3
(* d3 (+ 1 (* 3 (/ 1 d3))))
(* d3 (+ 1 (* 3 (/ 1 d3))))
(* d3 (+ 1 (* 3 (/ 1 d3))))
d3
(* d3 (+ 1 (* 3 (/ 1 d3))))
(* d3 (+ 1 (* 3 (/ 1 d3))))
(* d3 (+ 1 (* 3 (/ 1 d3))))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* -1 (* d1 (- (+ (* -1 d2) (* -1 d3)) 3)))
(* -1 (* d1 (- (+ (* -1 d2) (* -1 d3)) 3)))
(* -1 (* d1 (- (+ (* -1 d2) (* -1 d3)) 3)))
(* -1 (* d1 (- (+ (* -1 d2) (* -1 d3)) 3)))
(+ (* 3 d1) (* d1 d3))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(* d1 d2)
(* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))
(* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))
(* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))
(* d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))
(+ (* 3 d1) (* d1 d2))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(* d1 d3)
(* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))
(* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))
(* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))
(* d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* -1 (* d1 (- (* -1 d2) 3)))
(* -1 (* d1 (- (* -1 d2) 3)))
(* -1 (* d1 (- (* -1 d2) 3)))
(* -1 (* d1 (- (* -1 d2) 3)))
(* 3 d1)
(+ (* 3 d1) (* d1 d2))
(+ (* 3 d1) (* d1 d2))
(+ (* 3 d1) (* d1 d2))
(* d1 d2)
(* d2 (+ d1 (* 3 (/ d1 d2))))
(* d2 (+ d1 (* 3 (/ d1 d2))))
(* d2 (+ d1 (* 3 (/ d1 d2))))
(* d1 d2)
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)

Outputs
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(+ (* d1 d2) (* d1 (+ 3 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* d1 d2) (* d1 (+ 3 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* d1 d2) (* d1 (+ 3 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d2)
(*.f64 d1 d2)
(* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d2)
(*.f64 d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(+ (* d1 d3) (* d1 (+ 3 d2)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* d1 d3) (* d1 (+ 3 d2)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* d1 d3) (* d1 (+ 3 d2)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d3)
(*.f64 d1 d3)
(* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d3)
(*.f64 d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ 3 d3)
(+.f64 #s(literal 3 binary64) d3)
(+ 3 (+ d2 d3))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(+ 3 (+ d2 d3))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(+ 3 (+ d2 d3))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
d2
(* d2 (+ 1 (+ (* 3 (/ 1 d2)) (/ d3 d2))))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(* d2 (+ 1 (+ (* 3 (/ 1 d2)) (/ d3 d2))))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(* d2 (+ 1 (+ (* 3 (/ 1 d2)) (/ d3 d2))))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
d2
(* -1 (* d2 (- (* -1 (/ (+ 3 d3) d2)) 1)))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(* -1 (* d2 (- (* -1 (/ (+ 3 d3) d2)) 1)))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(* -1 (* d2 (- (* -1 (/ (+ 3 d3) d2)) 1)))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(+ 3 d2)
(+.f64 #s(literal 3 binary64) d2)
(+ 3 (+ d2 d3))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(+ 3 (+ d2 d3))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(+ 3 (+ d2 d3))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
d3
(* d3 (+ 1 (+ (* 3 (/ 1 d3)) (/ d2 d3))))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(* d3 (+ 1 (+ (* 3 (/ 1 d3)) (/ d2 d3))))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(* d3 (+ 1 (+ (* 3 (/ 1 d3)) (/ d2 d3))))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
d3
(* -1 (* d3 (- (* -1 (/ (+ 3 d2) d3)) 1)))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(* -1 (* d3 (- (* -1 (/ (+ 3 d2) d3)) 1)))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
(* -1 (* d3 (- (* -1 (/ (+ 3 d2) d3)) 1)))
(+.f64 #s(literal 3 binary64) (+.f64 d2 d3))
3
#s(literal 3 binary64)
(+ 3 d3)
(+.f64 #s(literal 3 binary64) d3)
(+ 3 d3)
(+.f64 #s(literal 3 binary64) d3)
(+ 3 d3)
(+.f64 #s(literal 3 binary64) d3)
d3
(* d3 (+ 1 (* 3 (/ 1 d3))))
(+.f64 #s(literal 3 binary64) d3)
(* d3 (+ 1 (* 3 (/ 1 d3))))
(+.f64 #s(literal 3 binary64) d3)
(* d3 (+ 1 (* 3 (/ 1 d3))))
(+.f64 #s(literal 3 binary64) d3)
d3
(* d3 (+ 1 (* 3 (/ 1 d3))))
(+.f64 #s(literal 3 binary64) d3)
(* d3 (+ 1 (* 3 (/ 1 d3))))
(+.f64 #s(literal 3 binary64) d3)
(* d3 (+ 1 (* 3 (/ 1 d3))))
(+.f64 #s(literal 3 binary64) d3)
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d1 (- (+ (* -1 d2) (* -1 d3)) 3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d1 (- (+ (* -1 d2) (* -1 d3)) 3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d1 (- (+ (* -1 d2) (* -1 d3)) 3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d1 (- (+ (* -1 d2) (* -1 d3)) 3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* 3 d1) (* d1 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d2)
(*.f64 d1 d2)
(* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d2)
(*.f64 d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* 3 d1) (* d1 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d3)
(*.f64 d1 d3)
(* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d3)
(*.f64 d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* -1 (* d1 (- (* -1 d2) 3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* -1 (* d1 (- (* -1 d2) 3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* -1 (* d1 (- (* -1 d2) 3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* -1 (* d1 (- (* -1 d2) 3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(+ (* 3 d1) (* d1 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(+ (* 3 d1) (* d1 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(+ (* 3 d1) (* d1 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* d1 d2)
(*.f64 d1 d2)
(* d2 (+ d1 (* 3 (/ d1 d2))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* d2 (+ d1 (* 3 (/ d1 d2))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* d2 (+ d1 (* 3 (/ d1 d2))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* d1 d2)
(*.f64 d1 d2)
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)

eval21.0ms (0.6%)

Compiler: Compiled 1807 to 72 computations (96% saved)

prune12.0ms (0.3%)

Pruning

9 alts after pruning (8 fresh and 1 done)

	Pruned	Kept	Total
New	220	8	228
Fresh	0	0	0
Picked	1	1	2
Done	0	0	0
Total	221	9	230

Accuracy

100.0%

Counts

230 → 9

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	98.4%	(fma.f64 (+.f64 d2 #s(literal 3 binary64)) d1 (*.f64 d1 d3))
▶	99.2%	(fma.f64 (+.f64 #s(literal 3 binary64) d3) d1 (*.f64 d1 d2))
	80.0%	(+.f64 (.f64 d1 d2) (.f64 d1 d3))
✓	99.9%	(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))
▶	82.4%	(*.f64 d1 (+.f64 d2 d3))
	63.1%	(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
▶	57.1%	(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
	40.7%	(*.f64 d1 d3)
▶	45.1%	(*.f64 d1 d2)

Compiler

Compiled 146 to 97 computations (33.6% saved)

simplify7.0ms (0.2%)

Algorithm

1×	egg-herbie

Localize:

Found 11 expressions of interest:

New	Metric	Score	Program
✓	cost-diff	0	(*.f64 d1 d3)
✓	cost-diff	0	(+.f64 d2 #s(literal 3 binary64))
✓	cost-diff	6400	(fma.f64 (+.f64 d2 #s(literal 3 binary64)) d1 (*.f64 d1 d3))
✓	cost-diff	0	(+.f64 d2 d3)
✓	cost-diff	0	(*.f64 d1 (+.f64 d2 d3))
✓	cost-diff	0	(+.f64 #s(literal 3 binary64) d3)
✓	cost-diff	0	(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
✓	cost-diff	0	(*.f64 d1 d2)
✓	cost-diff	0	(*.f64 d1 d2)
✓	cost-diff	0	(+.f64 #s(literal 3 binary64) d3)
✓	cost-diff	6400	(fma.f64 (+.f64 #s(literal 3 binary64) d3) d1 (*.f64 d1 d2))

Rules

48×	`fma-lowering-fma.f32`
48×	`fma-define`
48×	`+-lowering-+.f64`
48×	`+-lowering-+.f32`
48×	`fma-lowering-fma.f64`

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	15	63
1	33	61
2	62	59
3	84	59
4	90	59
0	90	59

Stop Event

1×	iter limit
1×	saturated

Calls

Call 1

Inputs
(+ (* (+ 3 d3) d1) (* d1 d2))
(+ 3 d3)
3
d3
d1
(* d1 d2)
d2
(* d1 d2)
d1
d2
(* d1 (+ 3 d3))
d1
(+ 3 d3)
3
d3
(* d1 (+ d2 d3))
d1
(+ d2 d3)
d2
d3
(+ (* (+ d2 3) d1) (* d1 d3))
(+ d2 3)
d2
3
d1
(* d1 d3)
d3

Outputs
(+ (* (+ 3 d3) d1) (* d1 d2))
(*.f64 d1 (+.f64 d3 (+.f64 #s(literal 3 binary64) d2)))
(+ 3 d3)
(+.f64 #s(literal 3 binary64) d3)
3
#s(literal 3 binary64)
d3
d1
(* d1 d2)
(*.f64 d1 d2)
d2
(* d1 d2)
(*.f64 d1 d2)
d1
d2
(* d1 (+ 3 d3))
(*.f64 (+.f64 #s(literal 3 binary64) d3) d1)
d1
(+ 3 d3)
(+.f64 #s(literal 3 binary64) d3)
3
#s(literal 3 binary64)
d3
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d3 d2))
d1
(+ d2 d3)
(+.f64 d3 d2)
d2
d3
(+ (* (+ d2 3) d1) (* d1 d3))
(*.f64 d1 (+.f64 d3 (+.f64 #s(literal 3 binary64) d2)))
(+ d2 3)
(+.f64 #s(literal 3 binary64) d2)
d2
3
#s(literal 3 binary64)
d1
(* d1 d3)
(*.f64 d3 d1)
d3

localize113.0ms (3.1%)

Localize:

Found 11 expressions of interest:

New	Metric	Score	Program
✓	accuracy	100.0%	(+.f64 d2 #s(literal 3 binary64))
✓	accuracy	100.0%	(*.f64 d1 d3)
✓	accuracy	98.4%	(fma.f64 (+.f64 d2 #s(literal 3 binary64)) d1 (*.f64 d1 d3))
✓	accuracy	100.0%	(+.f64 d2 d3)
✓	accuracy	100.0%	(*.f64 d1 (+.f64 d2 d3))
✓	accuracy	100.0%	(+.f64 #s(literal 3 binary64) d3)
✓	accuracy	99.9%	(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
✓	accuracy	100.0%	(*.f64 d1 d2)
✓	accuracy	100.0%	(+.f64 #s(literal 3 binary64) d3)
✓	accuracy	100.0%	(*.f64 d1 d2)
✓	accuracy	99.2%	(fma.f64 (+.f64 #s(literal 3 binary64) d3) d1 (*.f64 d1 d2))

Results

56.0ms	230×	0	valid
30.0ms	17×	5	exit
3.0ms	5×	2	valid
2.0ms	4×	1	valid

Compiler

Compiled 67 to 14 computations (79.1% saved)

Precisions

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

ival-mult: 18.0ms (37.7% of total)

compiled-spec: 15.0ms (31.4% of total)

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

backward-pass: 5.0ms (10.5% of total)

const: 0.0ms (0% of total)

series12.0ms (0.3%)

Counts

9 → 228

Calls

Call 1

Inputs
#<alt (+ (* (+ 3 d3) d1) (* d1 d2))>
#<alt (+ 3 d3)>
#<alt (* d1 d2)>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (+ d2 d3)>
#<alt (+ (* (+ d2 3) d1) (* d1 d3))>
#<alt (+ d2 3)>
#<alt (* d1 d3)>

Outputs
#<alt (+ (* 3 d1) (* d1 d2))>
#<alt (+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))>
#<alt (+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))>
#<alt (+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))>
#<alt (* d1 d3)>
#<alt (* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))>
#<alt (* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))>
#<alt (* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))>
#<alt (* d1 d3)>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 (+ 3 d3)))))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 (+ 3 d3)))))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 (+ 3 d3)))))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 (+ 3 d3)))))>
#<alt (* d1 (+ 3 d3))>
#<alt (+ (* d1 d2) (* d1 (+ 3 d3)))>
#<alt (+ (* d1 d2) (* d1 (+ 3 d3)))>
#<alt (+ (* d1 d2) (* d1 (+ 3 d3)))>
#<alt (* d1 d2)>
#<alt (* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))>
#<alt (* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))>
#<alt (* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))>
#<alt (* d1 d2)>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))>
#<alt 3>
#<alt (+ 3 d3)>
#<alt (+ 3 d3)>
#<alt (+ 3 d3)>
#<alt d3>
#<alt (* d3 (+ 1 (* 3 (/ 1 d3))))>
#<alt (* d3 (+ 1 (* 3 (/ 1 d3))))>
#<alt (* d3 (+ 1 (* 3 (/ 1 d3))))>
#<alt d3>
#<alt (* d3 (+ 1 (* 3 (/ 1 d3))))>
#<alt (* d3 (+ 1 (* 3 (/ 1 d3))))>
#<alt (* d3 (+ 1 (* 3 (/ 1 d3))))>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* 3 d1)>
#<alt (+ (* 3 d1) (* d1 d3))>
#<alt (+ (* 3 d1) (* d1 d3))>
#<alt (+ (* 3 d1) (* d1 d3))>
#<alt (* d1 d3)>
#<alt (* d3 (+ d1 (* 3 (/ d1 d3))))>
#<alt (* d3 (+ d1 (* 3 (/ d1 d3))))>
#<alt (* d3 (+ d1 (* 3 (/ d1 d3))))>
#<alt (* d1 d3)>
#<alt (* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))>
#<alt (* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))>
#<alt (* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 d3)>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (* d1 d2)>
#<alt (* d2 (+ d1 (/ (* d1 d3) d2)))>
#<alt (* d2 (+ d1 (/ (* d1 d3) d2)))>
#<alt (* d2 (+ d1 (/ (* d1 d3) d2)))>
#<alt (* d1 d2)>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))>
#<alt (* d1 d2)>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (* d1 d3)>
#<alt (* d3 (+ d1 (/ (* d1 d2) d3)))>
#<alt (* d3 (+ d1 (/ (* d1 d2) d3)))>
#<alt (* d3 (+ d1 (/ (* d1 d2) d3)))>
#<alt (* d1 d3)>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))>
#<alt d3>
#<alt (+ d2 d3)>
#<alt (+ d2 d3)>
#<alt (+ d2 d3)>
#<alt d2>
#<alt (* d2 (+ 1 (/ d3 d2)))>
#<alt (* d2 (+ 1 (/ d3 d2)))>
#<alt (* d2 (+ 1 (/ d3 d2)))>
#<alt d2>
#<alt (* -1 (* d2 (- (* -1 (/ d3 d2)) 1)))>
#<alt (* -1 (* d2 (- (* -1 (/ d3 d2)) 1)))>
#<alt (* -1 (* d2 (- (* -1 (/ d3 d2)) 1)))>
#<alt d2>
#<alt (+ d2 d3)>
#<alt (+ d2 d3)>
#<alt (+ d2 d3)>
#<alt d3>
#<alt (* d3 (+ 1 (/ d2 d3)))>
#<alt (* d3 (+ 1 (/ d2 d3)))>
#<alt (* d3 (+ 1 (/ d2 d3)))>
#<alt d3>
#<alt (* -1 (* d3 (- (* -1 (/ d2 d3)) 1)))>
#<alt (* -1 (* d3 (- (* -1 (/ d2 d3)) 1)))>
#<alt (* -1 (* d3 (- (* -1 (/ d2 d3)) 1)))>
#<alt (+ (* 3 d1) (* d1 d3))>
#<alt (+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))>
#<alt (+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))>
#<alt (+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))>
#<alt (* d1 d2)>
#<alt (* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))>
#<alt (* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))>
#<alt (* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))>
#<alt (* d1 d2)>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* d1 (+ 3 (+ d2 d3)))>
#<alt (* -1 (* d1 (+ (* -1 d3) (* -1 (+ 3 d2)))))>
#<alt (* -1 (* d1 (+ (* -1 d3) (* -1 (+ 3 d2)))))>
#<alt (* -1 (* d1 (+ (* -1 d3) (* -1 (+ 3 d2)))))>
#<alt (* -1 (* d1 (+ (* -1 d3) (* -1 (+ 3 d2)))))>
#<alt (* d1 (+ 3 d2))>
#<alt (+ (* d1 d3) (* d1 (+ 3 d2)))>
#<alt (+ (* d1 d3) (* d1 (+ 3 d2)))>
#<alt (+ (* d1 d3) (* d1 (+ 3 d2)))>
#<alt (* d1 d3)>
#<alt (* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))>
#<alt (* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))>
#<alt (* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))>
#<alt (* d1 d3)>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))>
#<alt 3>
#<alt (+ 3 d2)>
#<alt (+ 3 d2)>
#<alt (+ 3 d2)>
#<alt d2>
#<alt (* d2 (+ 1 (* 3 (/ 1 d2))))>
#<alt (* d2 (+ 1 (* 3 (/ 1 d2))))>
#<alt (* d2 (+ 1 (* 3 (/ 1 d2))))>
#<alt d2>
#<alt (* d2 (+ 1 (* 3 (/ 1 d2))))>
#<alt (* d2 (+ 1 (* 3 (/ 1 d2))))>
#<alt (* d2 (+ 1 (* 3 (/ 1 d2))))>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>

Calls

57 calls:

Time	Variable		Point	Expression
3.0ms	d3	@	inf	(+ (* (+ d2 3) d1) (* d1 d3))
1.0ms	d3	@	0	(+ (* (+ 3 d3) d1) (* d1 d2))
0.0ms	d1	@	-inf	(+ (* (+ 3 d3) d1) (* d1 d2))
0.0ms	d1	@	-inf	(+ (* (+ d2 3) d1) (* d1 d3))
0.0ms	d1	@	0	(+ (* (+ d2 3) d1) (* d1 d3))

rewrite14.0ms (0.4%)

Algorithm

1×	batch-egg-rewrite

Rules

48×	`fma-lowering-fma.f32`
48×	`fma-define`
48×	`+-lowering-+.f64`
48×	`+-lowering-+.f32`
48×	`fma-lowering-fma.f64`

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	15	41
1	33	39
2	62	37
3	84	37
4	90	37
0	90	37

Stop Event

1×	iter limit
1×	saturated

Counts

9 → 66

Calls

Call 1

Inputs
(+ (* (+ 3 d3) d1) (* d1 d2))
(+ 3 d3)
(* d1 d2)
(* d1 (+ 3 d3))
(* d1 (+ d2 d3))
(+ d2 d3)
(+ (* (+ d2 3) d1) (* d1 d3))
(+ d2 3)
(* d1 d3)

Outputs
(+.f64 (.f64 (+.f64 #s(literal 3 binary64) d3) d1) (.f64 d1 d2))
(+.f64 (.f64 d1 d2) (.f64 (+.f64 #s(literal 3 binary64) d3) d1))
(+.f64 (.f64 d1 (+.f64 d3 d2)) (.f64 #s(literal 3 binary64) d1))
(+.f64 (.f64 d1 (+.f64 #s(literal 3 binary64) d2)) (.f64 d3 d1))
(+.f64 (.f64 d3 d1) (.f64 d1 (+.f64 #s(literal 3 binary64) d2)))
(+.f64 (.f64 #s(literal 3 binary64) d1) (.f64 d1 (+.f64 d3 d2)))
(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 (+.f64 d3 d2)))
(fma.f64 d3 d1 (*.f64 d1 (+.f64 #s(literal 3 binary64) d2)))
(fma.f64 (+.f64 #s(literal 3 binary64) d3) d1 (*.f64 d1 d2))
(fma.f64 d1 #s(literal 3 binary64) (*.f64 d1 (+.f64 d3 d2)))
(fma.f64 d1 d3 (*.f64 d1 (+.f64 #s(literal 3 binary64) d2)))
(fma.f64 d1 (+.f64 #s(literal 3 binary64) d3) (*.f64 d1 d2))
(fma.f64 d1 d2 (*.f64 (+.f64 #s(literal 3 binary64) d3) d1))
(fma.f64 d1 (+.f64 d3 d2) (*.f64 #s(literal 3 binary64) d1))
(fma.f64 d1 (+.f64 #s(literal 3 binary64) d2) (*.f64 d3 d1))
(fma.f64 d2 d1 (*.f64 (+.f64 #s(literal 3 binary64) d3) d1))
(fma.f64 (+.f64 d3 d2) d1 (*.f64 #s(literal 3 binary64) d1))
(fma.f64 (+.f64 #s(literal 3 binary64) d2) d1 (*.f64 d3 d1))
(*.f64 d1 (+.f64 d3 (+.f64 #s(literal 3 binary64) d2)))
(*.f64 (+.f64 d3 (+.f64 #s(literal 3 binary64) d2)) d1)
(+.f64 #s(literal 3 binary64) d3)
(+.f64 d3 #s(literal 3 binary64))
(*.f64 d1 d2)
(*.f64 d2 d1)
(+.f64 (.f64 d3 d1) (.f64 #s(literal 3 binary64) d1))
(+.f64 (.f64 #s(literal 3 binary64) d1) (.f64 d3 d1))
(fma.f64 #s(literal 3 binary64) d1 (*.f64 d3 d1))
(fma.f64 d3 d1 (*.f64 #s(literal 3 binary64) d1))
(fma.f64 d1 #s(literal 3 binary64) (*.f64 d3 d1))
(fma.f64 d1 d3 (*.f64 #s(literal 3 binary64) d1))
(*.f64 (+.f64 #s(literal 3 binary64) d3) d1)
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(+.f64 (.f64 d1 d2) (.f64 d3 d1))
(+.f64 (.f64 d3 d1) (.f64 d1 d2))
(fma.f64 d3 d1 (*.f64 d1 d2))
(fma.f64 d1 d3 (*.f64 d1 d2))
(fma.f64 d1 d2 (*.f64 d3 d1))
(fma.f64 d2 d1 (*.f64 d3 d1))
(*.f64 d1 (+.f64 d3 d2))
(*.f64 (+.f64 d3 d2) d1)
(+.f64 d3 d2)
(+.f64 d2 d3)
(+.f64 (.f64 (+.f64 #s(literal 3 binary64) d3) d1) (.f64 d1 d2))
(+.f64 (.f64 d1 d2) (.f64 (+.f64 #s(literal 3 binary64) d3) d1))
(+.f64 (.f64 d1 (+.f64 d3 d2)) (.f64 #s(literal 3 binary64) d1))
(+.f64 (.f64 d1 (+.f64 #s(literal 3 binary64) d2)) (.f64 d3 d1))
(+.f64 (.f64 d3 d1) (.f64 d1 (+.f64 #s(literal 3 binary64) d2)))
(+.f64 (.f64 #s(literal 3 binary64) d1) (.f64 d1 (+.f64 d3 d2)))
(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 (+.f64 d3 d2)))
(fma.f64 d3 d1 (*.f64 d1 (+.f64 #s(literal 3 binary64) d2)))
(fma.f64 (+.f64 #s(literal 3 binary64) d3) d1 (*.f64 d1 d2))
(fma.f64 d1 #s(literal 3 binary64) (*.f64 d1 (+.f64 d3 d2)))
(fma.f64 d1 d3 (*.f64 d1 (+.f64 #s(literal 3 binary64) d2)))
(fma.f64 d1 (+.f64 #s(literal 3 binary64) d3) (*.f64 d1 d2))
(fma.f64 d1 d2 (*.f64 (+.f64 #s(literal 3 binary64) d3) d1))
(fma.f64 d1 (+.f64 d3 d2) (*.f64 #s(literal 3 binary64) d1))
(fma.f64 d1 (+.f64 #s(literal 3 binary64) d2) (*.f64 d3 d1))
(fma.f64 d2 d1 (*.f64 (+.f64 #s(literal 3 binary64) d3) d1))
(fma.f64 (+.f64 d3 d2) d1 (*.f64 #s(literal 3 binary64) d1))
(fma.f64 (+.f64 #s(literal 3 binary64) d2) d1 (*.f64 d3 d1))
(*.f64 d1 (+.f64 d3 (+.f64 #s(literal 3 binary64) d2)))
(*.f64 (+.f64 d3 (+.f64 #s(literal 3 binary64) d2)) d1)
(+.f64 #s(literal 3 binary64) d2)
(+.f64 d2 #s(literal 3 binary64))
(*.f64 d3 d1)
(*.f64 d1 d3)

simplify162.0ms (4.5%)

Algorithm

1×	egg-herbie

Rules

3062×	`-lowering-.f32`
3062×	`-lowering-.f64`
1550×	`fmsub-define`
1372×	`fnmsub-define`
1262×	`+-lowering-+.f64`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	111	1010
1	422	950
2	1142	950
3	3649	950
0	8151	950

Stop Event

1×	iter limit
1×	node limit

Counts

228 → 228

Calls

Call 1

Inputs
(+ (* 3 d1) (* d1 d2))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(* d1 d3)
(* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))
(* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))
(* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))
(* d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* -1 (* d1 (+ (* -1 d2) (* -1 (+ 3 d3)))))
(* -1 (* d1 (+ (* -1 d2) (* -1 (+ 3 d3)))))
(* -1 (* d1 (+ (* -1 d2) (* -1 (+ 3 d3)))))
(* -1 (* d1 (+ (* -1 d2) (* -1 (+ 3 d3)))))
(* d1 (+ 3 d3))
(+ (* d1 d2) (* d1 (+ 3 d3)))
(+ (* d1 d2) (* d1 (+ 3 d3)))
(+ (* d1 d2) (* d1 (+ 3 d3)))
(* d1 d2)
(* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))
(* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))
(* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))
(* d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))
3
(+ 3 d3)
(+ 3 d3)
(+ 3 d3)
d3
(* d3 (+ 1 (* 3 (/ 1 d3))))
(* d3 (+ 1 (* 3 (/ 1 d3))))
(* d3 (+ 1 (* 3 (/ 1 d3))))
d3
(* d3 (+ 1 (* 3 (/ 1 d3))))
(* d3 (+ 1 (* 3 (/ 1 d3))))
(* d3 (+ 1 (* 3 (/ 1 d3))))
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* 3 d1)
(+ (* 3 d1) (* d1 d3))
(+ (* 3 d1) (* d1 d3))
(+ (* 3 d1) (* d1 d3))
(* d1 d3)
(* d3 (+ d1 (* 3 (/ d1 d3))))
(* d3 (+ d1 (* 3 (/ d1 d3))))
(* d3 (+ d1 (* 3 (/ d1 d3))))
(* d1 d3)
(* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))
(* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))
(* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 d3)
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(* d1 d2)
(* d2 (+ d1 (/ (* d1 d3) d2)))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(* d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(* d1 d2)
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(* d1 d3)
(* d3 (+ d1 (/ (* d1 d2) d3)))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(* d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
d3
(+ d2 d3)
(+ d2 d3)
(+ d2 d3)
d2
(* d2 (+ 1 (/ d3 d2)))
(* d2 (+ 1 (/ d3 d2)))
(* d2 (+ 1 (/ d3 d2)))
d2
(* -1 (* d2 (- (* -1 (/ d3 d2)) 1)))
(* -1 (* d2 (- (* -1 (/ d3 d2)) 1)))
(* -1 (* d2 (- (* -1 (/ d3 d2)) 1)))
d2
(+ d2 d3)
(+ d2 d3)
(+ d2 d3)
d3
(* d3 (+ 1 (/ d2 d3)))
(* d3 (+ 1 (/ d2 d3)))
(* d3 (+ 1 (/ d2 d3)))
d3
(* -1 (* d3 (- (* -1 (/ d2 d3)) 1)))
(* -1 (* d3 (- (* -1 (/ d2 d3)) 1)))
(* -1 (* d3 (- (* -1 (/ d2 d3)) 1)))
(+ (* 3 d1) (* d1 d3))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(* d1 d2)
(* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))
(* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))
(* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))
(* d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(* -1 (* d1 (+ (* -1 d3) (* -1 (+ 3 d2)))))
(* -1 (* d1 (+ (* -1 d3) (* -1 (+ 3 d2)))))
(* -1 (* d1 (+ (* -1 d3) (* -1 (+ 3 d2)))))
(* -1 (* d1 (+ (* -1 d3) (* -1 (+ 3 d2)))))
(* d1 (+ 3 d2))
(+ (* d1 d3) (* d1 (+ 3 d2)))
(+ (* d1 d3) (* d1 (+ 3 d2)))
(+ (* d1 d3) (* d1 (+ 3 d2)))
(* d1 d3)
(* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))
(* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))
(* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))
(* d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))
3
(+ 3 d2)
(+ 3 d2)
(+ 3 d2)
d2
(* d2 (+ 1 (* 3 (/ 1 d2))))
(* d2 (+ 1 (* 3 (/ 1 d2))))
(* d2 (+ 1 (* 3 (/ 1 d2))))
d2
(* d2 (+ 1 (* 3 (/ 1 d2))))
(* d2 (+ 1 (* 3 (/ 1 d2))))
(* d2 (+ 1 (* 3 (/ 1 d2))))
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)

Outputs
(+ (* 3 d1) (* d1 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d3)
(*.f64 d1 d3)
(* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d3 (+ d1 (+ (* 3 (/ d1 d3)) (/ (* d1 d2) d3))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d3)
(*.f64 d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d2)) d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d1 (+ (* -1 d2) (* -1 (+ 3 d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d1 (+ (* -1 d2) (* -1 (+ 3 d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d1 (+ (* -1 d2) (* -1 (+ 3 d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d1 (+ (* -1 d2) (* -1 (+ 3 d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(+ (* d1 d2) (* d1 (+ 3 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* d1 d2) (* d1 (+ 3 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* d1 d2) (* d1 (+ 3 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d2)
(*.f64 d1 d2)
(* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d2 (+ d1 (/ (* d1 (+ 3 d3)) d2)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d2)
(*.f64 d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d3)) d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
3
#s(literal 3 binary64)
(+ 3 d3)
(+.f64 #s(literal 3 binary64) d3)
(+ 3 d3)
(+.f64 #s(literal 3 binary64) d3)
(+ 3 d3)
(+.f64 #s(literal 3 binary64) d3)
d3
(* d3 (+ 1 (* 3 (/ 1 d3))))
(+.f64 #s(literal 3 binary64) d3)
(* d3 (+ 1 (* 3 (/ 1 d3))))
(+.f64 #s(literal 3 binary64) d3)
(* d3 (+ 1 (* 3 (/ 1 d3))))
(+.f64 #s(literal 3 binary64) d3)
d3
(* d3 (+ 1 (* 3 (/ 1 d3))))
(+.f64 #s(literal 3 binary64) d3)
(* d3 (+ 1 (* 3 (/ 1 d3))))
(+.f64 #s(literal 3 binary64) d3)
(* d3 (+ 1 (* 3 (/ 1 d3))))
(+.f64 #s(literal 3 binary64) d3)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* 3 d1)
(*.f64 #s(literal 3 binary64) d1)
(+ (* 3 d1) (* d1 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(+ (* 3 d1) (* d1 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(+ (* 3 d1) (* d1 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 d3)
(*.f64 d1 d3)
(* d3 (+ d1 (* 3 (/ d1 d3))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d3 (+ d1 (* 3 (/ d1 d3))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d3 (+ d1 (* 3 (/ d1 d3))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 d3)
(*.f64 d1 d3)
(* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d3)
(*.f64 d1 d3)
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d2)
(*.f64 d1 d2)
(* d2 (+ d1 (/ (* d1 d3) d2)))
(*.f64 d1 (+.f64 d2 d3))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(*.f64 d1 (+.f64 d2 d3))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d2)
(*.f64 d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d2)
(*.f64 d1 d2)
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d3)
(*.f64 d1 d3)
(* d3 (+ d1 (/ (* d1 d2) d3)))
(*.f64 d1 (+.f64 d2 d3))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(*.f64 d1 (+.f64 d2 d3))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d3)
(*.f64 d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(*.f64 d1 (+.f64 d2 d3))
d3
(+ d2 d3)
(+.f64 d2 d3)
(+ d2 d3)
(+.f64 d2 d3)
(+ d2 d3)
(+.f64 d2 d3)
d2
(* d2 (+ 1 (/ d3 d2)))
(+.f64 d2 d3)
(* d2 (+ 1 (/ d3 d2)))
(+.f64 d2 d3)
(* d2 (+ 1 (/ d3 d2)))
(+.f64 d2 d3)
d2
(* -1 (* d2 (- (* -1 (/ d3 d2)) 1)))
(+.f64 d2 d3)
(* -1 (* d2 (- (* -1 (/ d3 d2)) 1)))
(+.f64 d2 d3)
(* -1 (* d2 (- (* -1 (/ d3 d2)) 1)))
(+.f64 d2 d3)
d2
(+ d2 d3)
(+.f64 d2 d3)
(+ d2 d3)
(+.f64 d2 d3)
(+ d2 d3)
(+.f64 d2 d3)
d3
(* d3 (+ 1 (/ d2 d3)))
(+.f64 d2 d3)
(* d3 (+ 1 (/ d2 d3)))
(+.f64 d2 d3)
(* d3 (+ 1 (/ d2 d3)))
(+.f64 d2 d3)
d3
(* -1 (* d3 (- (* -1 (/ d2 d3)) 1)))
(+.f64 d2 d3)
(* -1 (* d3 (- (* -1 (/ d2 d3)) 1)))
(+.f64 d2 d3)
(* -1 (* d3 (- (* -1 (/ d2 d3)) 1)))
(+.f64 d2 d3)
(+ (* 3 d1) (* d1 d3))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* 3 d1) (+ (* d1 d2) (* d1 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d2)
(*.f64 d1 d2)
(* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d2 (+ d1 (+ (* 3 (/ d1 d2)) (/ (* d1 d3) d2))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d2)
(*.f64 d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (+ (* 3 d1) (* d1 d3)) d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 (+ d2 d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d1 (+ (* -1 d3) (* -1 (+ 3 d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d1 (+ (* -1 d3) (* -1 (+ 3 d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d1 (+ (* -1 d3) (* -1 (+ 3 d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d1 (+ (* -1 d3) (* -1 (+ 3 d2)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d2))
(+ (* d1 d3) (* d1 (+ 3 d2)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* d1 d3) (* d1 (+ 3 d2)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(+ (* d1 d3) (* d1 (+ 3 d2)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d3)
(*.f64 d1 d3)
(* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d3 (+ d1 (/ (* d1 (+ 3 d2)) d3)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* d1 d3)
(*.f64 d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 (+ 3 d2)) d3)))))
(*.f64 d1 (+.f64 #s(literal 3 binary64) (+.f64 d2 d3)))
3
#s(literal 3 binary64)
(+ 3 d2)
(+.f64 #s(literal 3 binary64) d2)
(+ 3 d2)
(+.f64 #s(literal 3 binary64) d2)
(+ 3 d2)
(+.f64 #s(literal 3 binary64) d2)
d2
(* d2 (+ 1 (* 3 (/ 1 d2))))
(+.f64 #s(literal 3 binary64) d2)
(* d2 (+ 1 (* 3 (/ 1 d2))))
(+.f64 #s(literal 3 binary64) d2)
(* d2 (+ 1 (* 3 (/ 1 d2))))
(+.f64 #s(literal 3 binary64) d2)
d2
(* d2 (+ 1 (* 3 (/ 1 d2))))
(+.f64 #s(literal 3 binary64) d2)
(* d2 (+ 1 (* 3 (/ 1 d2))))
(+.f64 #s(literal 3 binary64) d2)
(* d2 (+ 1 (* 3 (/ 1 d2))))
(+.f64 #s(literal 3 binary64) d2)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)

eval32.0ms (0.9%)

Compiler: Compiled 2061 to 66 computations (96.8% saved)

prune13.0ms (0.4%)

Pruning

13 alts after pruning (8 fresh and 5 done)

	Pruned	Kept	Total
New	328	6	334
Fresh	1	2	3
Picked	1	4	5
Done	0	1	1
Total	330	13	343

Accuracy

100.0%

Counts

343 → 13

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	99.2%	(fma.f64 (+.f64 #s(literal 3 binary64) d3) d1 (*.f64 d1 d2))
▶	81.6%	(fma.f64 d3 d1 (*.f64 d1 d2))
▶	80.8%	(fma.f64 d2 d1 (*.f64 d3 d1))
	57.2%	(fma.f64 d1 #s(literal 3 binary64) (*.f64 d3 d1))
▶	63.1%	(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 d2))
	80.0%	(+.f64 (.f64 d3 d1) (.f64 d1 d2))
✓	99.9%	(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))
✓	82.4%	(*.f64 d1 (+.f64 d2 d3))
▶	63.1%	(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
✓	57.1%	(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
	40.7%	(*.f64 d1 d3)
✓	45.1%	(*.f64 d1 d2)
▶	19.7%	(*.f64 d1 #s(literal 3 binary64))

Compiler

Compiled 175 to 115 computations (34.3% saved)

simplify5.0ms (0.1%)

Algorithm

1×	egg-herbie

Localize:

Found 9 expressions of interest:

New	Metric	Score	Program
✓	cost-diff	0	(*.f64 d3 d1)
✓	cost-diff	6400	(fma.f64 d2 d1 (*.f64 d3 d1))
✓	cost-diff	0	(*.f64 d1 d2)
✓	cost-diff	6400	(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 d2))
✓	cost-diff	0	(+.f64 d2 #s(literal 3 binary64))
✓	cost-diff	0	(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
✓	cost-diff	0	(*.f64 d1 #s(literal 3 binary64))
✓	cost-diff	0	(*.f64 d1 d2)
✓	cost-diff	6400	(fma.f64 d3 d1 (*.f64 d1 d2))

Rules

20×	`-lowering-.f32`
20×	`-lowering-.f64`
16×	`fma-lowering-fma.f32`
16×	`fma-define`
16×	`+-lowering-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	14	49
1	27	49
2	35	49
0	35	49

Stop Event

1×	iter limit
1×	saturated

Calls

Call 1

Inputs
(+ (* d3 d1) (* d1 d2))
d3
d1
(* d1 d2)
d2
(* d1 3)
d1
3
(* d1 (+ d2 3))
d1
(+ d2 3)
d2
3
(+ (* 3 d1) (* d1 d2))
3
d1
(* d1 d2)
d2
(+ (* d2 d1) (* d3 d1))
d2
d1
(* d3 d1)
d3

Outputs
(+ (* d3 d1) (* d1 d2))
(*.f64 d1 (+.f64 d3 d2))
d3
d1
(* d1 d2)
(*.f64 d1 d2)
d2
(* d1 3)
(*.f64 d1 #s(literal 3 binary64))
d1
3
#s(literal 3 binary64)
(* d1 (+ d2 3))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
d1
(+ d2 3)
(+.f64 d2 #s(literal 3 binary64))
d2
3
#s(literal 3 binary64)
(+ (* 3 d1) (* d1 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
3
#s(literal 3 binary64)
d1
(* d1 d2)
(*.f64 d1 d2)
d2
(+ (* d2 d1) (* d3 d1))
(*.f64 d1 (+.f64 d3 d2))
d2
d1
(* d3 d1)
(*.f64 d3 d1)
d3

localize116.0ms (3.2%)

Localize:

Found 9 expressions of interest:

New	Metric	Score	Program
✓	accuracy	100.0%	(*.f64 d3 d1)
✓	accuracy	98.4%	(fma.f64 d2 d1 (*.f64 d3 d1))
✓	accuracy	100.0%	(*.f64 d1 d2)
✓	accuracy	100.0%	(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 d2))
✓	accuracy	100.0%	(+.f64 d2 #s(literal 3 binary64))
✓	accuracy	100.0%	(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
✓	accuracy	100.0%	(*.f64 d1 #s(literal 3 binary64))
✓	accuracy	100.0%	(*.f64 d1 d2)
✓	accuracy	99.2%	(fma.f64 d3 d1 (*.f64 d1 d2))

Results

55.0ms	231×	0	valid
36.0ms	25×	5	exit

Compiler

Compiled 56 to 13 computations (76.8% saved)

Precisions

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

ival-mult: 17.0ms (37.3% of total)

compiled-spec: 16.0ms (35.1% of total)

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

backward-pass: 5.0ms (11% of total)

const: 0.0ms (0% of total)

series3.0ms (0.1%)

Counts

8 → 192

Calls

Call 1

Inputs
#<alt (+ (* d3 d1) (* d1 d2))>
#<alt (* d1 d2)>
#<alt (* d1 3)>
#<alt (* d1 (+ d2 3))>
#<alt (+ d2 3)>
#<alt (+ (* 3 d1) (* d1 d2))>
#<alt (+ (* d2 d1) (* d3 d1))>
#<alt (* d3 d1)>

Outputs
#<alt (* d1 d2)>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (* d1 d3)>
#<alt (* d3 (+ d1 (/ (* d1 d2) d3)))>
#<alt (* d3 (+ d1 (/ (* d1 d2) d3)))>
#<alt (* d3 (+ d1 (/ (* d1 d2) d3)))>
#<alt (* d1 d3)>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 d3))))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 d3))))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 d3))))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 d3))))>
#<alt (* d1 d3)>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (* d1 d2)>
#<alt (* d2 (+ d1 (/ (* d1 d3) d2)))>
#<alt (* d2 (+ d1 (/ (* d1 d3) d2)))>
#<alt (* d2 (+ d1 (/ (* d1 d3) d2)))>
#<alt (* d1 d2)>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* 3 d1)>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* 3 d1)>
#<alt (+ (* 3 d1) (* d1 d2))>
#<alt (+ (* 3 d1) (* d1 d2))>
#<alt (+ (* 3 d1) (* d1 d2))>
#<alt (* d1 d2)>
#<alt (* d2 (+ d1 (* 3 (/ d1 d2))))>
#<alt (* d2 (+ d1 (* 3 (/ d1 d2))))>
#<alt (* d2 (+ d1 (* 3 (/ d1 d2))))>
#<alt (* d1 d2)>
#<alt (* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))>
#<alt (* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))>
#<alt (* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))>
#<alt 3>
#<alt (+ 3 d2)>
#<alt (+ 3 d2)>
#<alt (+ 3 d2)>
#<alt d2>
#<alt (* d2 (+ 1 (* 3 (/ 1 d2))))>
#<alt (* d2 (+ 1 (* 3 (/ 1 d2))))>
#<alt (* d2 (+ 1 (* 3 (/ 1 d2))))>
#<alt d2>
#<alt (* d2 (+ 1 (* 3 (/ 1 d2))))>
#<alt (* d2 (+ 1 (* 3 (/ 1 d2))))>
#<alt (* d2 (+ 1 (* 3 (/ 1 d2))))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* d1 (+ 3 d2))>
#<alt (* -1 (* d1 (- (* -1 d2) 3)))>
#<alt (* -1 (* d1 (- (* -1 d2) 3)))>
#<alt (* -1 (* d1 (- (* -1 d2) 3)))>
#<alt (* -1 (* d1 (- (* -1 d2) 3)))>
#<alt (* 3 d1)>
#<alt (+ (* 3 d1) (* d1 d2))>
#<alt (+ (* 3 d1) (* d1 d2))>
#<alt (+ (* 3 d1) (* d1 d2))>
#<alt (* d1 d2)>
#<alt (* d2 (+ d1 (* 3 (/ d1 d2))))>
#<alt (* d2 (+ d1 (* 3 (/ d1 d2))))>
#<alt (* d2 (+ d1 (* 3 (/ d1 d2))))>
#<alt (* d1 d2)>
#<alt (* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))>
#<alt (* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))>
#<alt (* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))>
#<alt (* d1 d3)>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (* d1 d2)>
#<alt (* d2 (+ d1 (/ (* d1 d3) d2)))>
#<alt (* d2 (+ d1 (/ (* d1 d3) d2)))>
#<alt (* d2 (+ d1 (/ (* d1 d3) d2)))>
#<alt (* d1 d2)>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 d3))))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 d3))))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 d3))))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 d3))))>
#<alt (* d1 d2)>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (* d1 d3)>
#<alt (* d3 (+ d1 (/ (* d1 d2) d3)))>
#<alt (* d3 (+ d1 (/ (* d1 d2) d3)))>
#<alt (* d3 (+ d1 (/ (* d1 d2) d3)))>
#<alt (* d1 d3)>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>

Calls

48 calls:

Time	Variable		Point	Expression
0.0ms	d3	@	-inf	(+ (* d3 d1) (* d1 d2))
0.0ms	d3	@	inf	(+ (* d3 d1) (* d1 d2))
0.0ms	d1	@	0	(* d1 (+ d2 3))
0.0ms	d1	@	-inf	(+ (* d3 d1) (* d1 d2))
0.0ms	d3	@	0	(+ (* d3 d1) (* d1 d2))

rewrite11.0ms (0.3%)

Algorithm

1×	batch-egg-rewrite

Rules

20×	`-lowering-.f32`
20×	`-lowering-.f64`
16×	`fma-lowering-fma.f32`
16×	`fma-define`
16×	`+-lowering-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	14	32
1	27	32
2	35	32
0	35	32

Stop Event

1×	iter limit
1×	saturated

Counts

8 → 40

Calls

Call 1

Inputs
(+ (* d3 d1) (* d1 d2))
(* d1 d2)
(* d1 3)
(* d1 (+ d2 3))
(+ d2 3)
(+ (* 3 d1) (* d1 d2))
(+ (* d2 d1) (* d3 d1))
(* d3 d1)

Outputs
(+.f64 (.f64 d3 d1) (.f64 d1 d2))
(+.f64 (.f64 d1 d2) (.f64 d3 d1))
(fma.f64 d3 d1 (*.f64 d1 d2))
(fma.f64 d1 d3 (*.f64 d1 d2))
(fma.f64 d1 d2 (*.f64 d3 d1))
(fma.f64 d2 d1 (*.f64 d3 d1))
(*.f64 d1 (+.f64 d3 d2))
(*.f64 (+.f64 d3 d2) d1)
(*.f64 d1 d2)
(*.f64 d2 d1)
(*.f64 d1 #s(literal 3 binary64))
(*.f64 #s(literal 3 binary64) d1)
(+.f64 (.f64 d1 d2) (.f64 d1 #s(literal 3 binary64)))
(+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d2))
(fma.f64 d1 d2 (*.f64 d1 #s(literal 3 binary64)))
(fma.f64 d1 #s(literal 3 binary64) (*.f64 d1 d2))
(fma.f64 d2 d1 (*.f64 d1 #s(literal 3 binary64)))
(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(*.f64 (+.f64 d2 #s(literal 3 binary64)) d1)
(+.f64 d2 #s(literal 3 binary64))
(+.f64 #s(literal 3 binary64) d2)
(+.f64 (.f64 d1 d2) (.f64 d1 #s(literal 3 binary64)))
(+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d2))
(fma.f64 d1 d2 (*.f64 d1 #s(literal 3 binary64)))
(fma.f64 d1 #s(literal 3 binary64) (*.f64 d1 d2))
(fma.f64 d2 d1 (*.f64 d1 #s(literal 3 binary64)))
(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(*.f64 (+.f64 d2 #s(literal 3 binary64)) d1)
(+.f64 (.f64 d3 d1) (.f64 d1 d2))
(+.f64 (.f64 d1 d2) (.f64 d3 d1))
(fma.f64 d3 d1 (*.f64 d1 d2))
(fma.f64 d1 d3 (*.f64 d1 d2))
(fma.f64 d1 d2 (*.f64 d3 d1))
(fma.f64 d2 d1 (*.f64 d3 d1))
(*.f64 d1 (+.f64 d3 d2))
(*.f64 (+.f64 d3 d2) d1)
(*.f64 d3 d1)
(*.f64 d1 d3)

simplify155.0ms (4.3%)

Algorithm

1×	egg-herbie

Rules

2096×	`fnmadd-define`
2056×	`fma-lowering-fma.f32`
2056×	`fma-lowering-fma.f64`
1938×	`fmsub-define`
1854×	`fnmsub-define`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	51	774
1	180	774
2	518	774
3	1548	774
4	4442	774
0	8124	774

Stop Event

1×	iter limit
1×	node limit

Counts

192 → 192

Calls

Call 1

Inputs
(* d1 d2)
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(* d1 d3)
(* d3 (+ d1 (/ (* d1 d2) d3)))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(* d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(* d1 d3)
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(* d1 d2)
(* d2 (+ d1 (/ (* d1 d3) d2)))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(* d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* 3 d1)
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* 3 d1)
(+ (* 3 d1) (* d1 d2))
(+ (* 3 d1) (* d1 d2))
(+ (* 3 d1) (* d1 d2))
(* d1 d2)
(* d2 (+ d1 (* 3 (/ d1 d2))))
(* d2 (+ d1 (* 3 (/ d1 d2))))
(* d2 (+ d1 (* 3 (/ d1 d2))))
(* d1 d2)
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
3
(+ 3 d2)
(+ 3 d2)
(+ 3 d2)
d2
(* d2 (+ 1 (* 3 (/ 1 d2))))
(* d2 (+ 1 (* 3 (/ 1 d2))))
(* d2 (+ 1 (* 3 (/ 1 d2))))
d2
(* d2 (+ 1 (* 3 (/ 1 d2))))
(* d2 (+ 1 (* 3 (/ 1 d2))))
(* d2 (+ 1 (* 3 (/ 1 d2))))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* d1 (+ 3 d2))
(* -1 (* d1 (- (* -1 d2) 3)))
(* -1 (* d1 (- (* -1 d2) 3)))
(* -1 (* d1 (- (* -1 d2) 3)))
(* -1 (* d1 (- (* -1 d2) 3)))
(* 3 d1)
(+ (* 3 d1) (* d1 d2))
(+ (* 3 d1) (* d1 d2))
(+ (* 3 d1) (* d1 d2))
(* d1 d2)
(* d2 (+ d1 (* 3 (/ d1 d2))))
(* d2 (+ d1 (* 3 (/ d1 d2))))
(* d2 (+ d1 (* 3 (/ d1 d2))))
(* d1 d2)
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(* d1 d3)
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(* d1 d2)
(* d2 (+ d1 (/ (* d1 d3) d2)))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(* d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(* d1 d2)
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(* d1 d3)
(* d3 (+ d1 (/ (* d1 d2) d3)))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(* d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)

Outputs
(* d1 d2)
(*.f64 d1 d2)
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d3)
(*.f64 d1 d3)
(* d3 (+ d1 (/ (* d1 d2) d3)))
(*.f64 d1 (+.f64 d2 d3))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(*.f64 d1 (+.f64 d2 d3))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d3)
(*.f64 d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d3)
(*.f64 d1 d3)
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d2)
(*.f64 d1 d2)
(* d2 (+ d1 (/ (* d1 d3) d2)))
(*.f64 d1 (+.f64 d2 d3))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(*.f64 d1 (+.f64 d2 d3))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d2)
(*.f64 d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(+ (* 3 d1) (* d1 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(+ (* 3 d1) (* d1 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(+ (* 3 d1) (* d1 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 d2)
(*.f64 d1 d2)
(* d2 (+ d1 (* 3 (/ d1 d2))))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d2 (+ d1 (* 3 (/ d1 d2))))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d2 (+ d1 (* 3 (/ d1 d2))))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 d2)
(*.f64 d1 d2)
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
3
#s(literal 3 binary64)
(+ 3 d2)
(+.f64 d2 #s(literal 3 binary64))
(+ 3 d2)
(+.f64 d2 #s(literal 3 binary64))
(+ 3 d2)
(+.f64 d2 #s(literal 3 binary64))
d2
(* d2 (+ 1 (* 3 (/ 1 d2))))
(+.f64 d2 #s(literal 3 binary64))
(* d2 (+ 1 (* 3 (/ 1 d2))))
(+.f64 d2 #s(literal 3 binary64))
(* d2 (+ 1 (* 3 (/ 1 d2))))
(+.f64 d2 #s(literal 3 binary64))
d2
(* d2 (+ 1 (* 3 (/ 1 d2))))
(+.f64 d2 #s(literal 3 binary64))
(* d2 (+ 1 (* 3 (/ 1 d2))))
(+.f64 d2 #s(literal 3 binary64))
(* d2 (+ 1 (* 3 (/ 1 d2))))
(+.f64 d2 #s(literal 3 binary64))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 (+ 3 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* -1 (* d1 (- (* -1 d2) 3)))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* -1 (* d1 (- (* -1 d2) 3)))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* -1 (* d1 (- (* -1 d2) 3)))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* -1 (* d1 (- (* -1 d2) 3)))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(+ (* 3 d1) (* d1 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(+ (* 3 d1) (* d1 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(+ (* 3 d1) (* d1 d2))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 d2)
(*.f64 d1 d2)
(* d2 (+ d1 (* 3 (/ d1 d2))))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d2 (+ d1 (* 3 (/ d1 d2))))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d2 (+ d1 (* 3 (/ d1 d2))))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 d2)
(*.f64 d1 d2)
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* -1 (* d2 (+ (* -3 (/ d1 d2)) (* -1 d1))))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(* d1 d3)
(*.f64 d1 d3)
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d2)
(*.f64 d1 d2)
(* d2 (+ d1 (/ (* d1 d3) d2)))
(*.f64 d1 (+.f64 d2 d3))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(*.f64 d1 (+.f64 d2 d3))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d2)
(*.f64 d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d2)
(*.f64 d1 d2)
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d3)
(*.f64 d1 d3)
(* d3 (+ d1 (/ (* d1 d2) d3)))
(*.f64 d1 (+.f64 d2 d3))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(*.f64 d1 (+.f64 d2 d3))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d3)
(*.f64 d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(*.f64 d1 (+.f64 d2 d3))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(*.f64 d1 (+.f64 d2 d3))
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)

eval24.0ms (0.7%)

Compiler: Compiled 1333 to 35 computations (97.4% saved)

prune7.0ms (0.2%)

Pruning

13 alts after pruning (3 fresh and 10 done)

	Pruned	Kept	Total
New	258	0	258
Fresh	0	3	3
Picked	0	5	5
Done	0	5	5
Total	258	13	271

Accuracy

100.0%

Counts

271 → 13

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	99.2%	(fma.f64 (+.f64 #s(literal 3 binary64) d3) d1 (*.f64 d1 d2))
✓	81.6%	(fma.f64 d3 d1 (*.f64 d1 d2))
✓	80.8%	(fma.f64 d2 d1 (*.f64 d3 d1))
▶	57.2%	(fma.f64 d1 #s(literal 3 binary64) (*.f64 d3 d1))
✓	63.1%	(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 d2))
▶	80.0%	(+.f64 (.f64 d3 d1) (.f64 d1 d2))
✓	99.9%	(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))
✓	82.4%	(*.f64 d1 (+.f64 d2 d3))
✓	63.1%	(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
✓	57.1%	(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
▶	40.7%	(*.f64 d1 d3)
✓	45.1%	(*.f64 d1 d2)
✓	19.7%	(*.f64 d1 #s(literal 3 binary64))

Compiler

Compiled 109 to 72 computations (33.9% saved)

simplify5.0ms (0.1%)

Algorithm

1×	egg-herbie

Localize:

Found 6 expressions of interest:

New	Metric	Score	Program
✓	cost-diff	0	(*.f64 d3 d1)
✓	cost-diff	6400	(fma.f64 d1 #s(literal 3 binary64) (*.f64 d3 d1))
✓	cost-diff	0	(*.f64 d1 d2)
✓	cost-diff	0	(*.f64 d3 d1)
✓	cost-diff	128	(+.f64 (.f64 d3 d1) (.f64 d1 d2))
✓	cost-diff	0	(*.f64 d1 d3)

Rules

20×	`-lowering-.f32`
20×	`-lowering-.f64`
16×	`fma-lowering-fma.f32`
16×	`fma-define`
16×	`+-lowering-+.f64`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	10	32
1	16	30
2	30	30
3	32	30
0	32	30

Stop Event

1×	iter limit
1×	saturated

Calls

Call 1

Inputs
(* d1 d3)
d1
d3
(+ (* d3 d1) (* d1 d2))
(* d3 d1)
d3
d1
(* d1 d2)
d2
(+ (* d1 3) (* d3 d1))
d1
3
(* d3 d1)
d3

Outputs
(* d1 d3)
(*.f64 d1 d3)
d1
d3
(+ (* d3 d1) (* d1 d2))
(*.f64 d1 (+.f64 d3 d2))
(* d3 d1)
(*.f64 d1 d3)
d3
d1
(* d1 d2)
(*.f64 d1 d2)
d2
(+ (* d1 3) (* d3 d1))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
d1
3
#s(literal 3 binary64)
(* d3 d1)
(*.f64 d1 d3)
d3

localize62.0ms (1.7%)

Localize:

Found 6 expressions of interest:

New	Metric	Score	Program
✓	accuracy	100.0%	(*.f64 d3 d1)
✓	accuracy	100.0%	(fma.f64 d1 #s(literal 3 binary64) (*.f64 d3 d1))
✓	accuracy	100.0%	(*.f64 d3 d1)
✓	accuracy	100.0%	(*.f64 d1 d2)
✓	accuracy	97.8%	(+.f64 (.f64 d3 d1) (.f64 d1 d2))
✓	accuracy	100.0%	(*.f64 d1 d3)

Results

40.0ms	232×	0	valid
6.0ms	13×	2	valid
3.0ms	11×	1	valid

Compiler

Compiled 37 to 10 computations (73% saved)

Precisions

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

ival-mult: 10.0ms (40.2% of total)

compiled-spec: 6.0ms (24.1% of total)

const: 4.0ms (16.1% of total)

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

backward-pass: 1.0ms (4% of total)

series2.0ms (0%)

Counts

5 → 132

Calls

Call 1

Inputs
#<alt (* d1 d3)>
#<alt (+ (* d3 d1) (* d1 d2))>
#<alt (* d3 d1)>
#<alt (* d1 d2)>
#<alt (+ (* d1 3) (* d3 d1))>

Outputs
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d2)>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (* d1 d3)>
#<alt (* d3 (+ d1 (/ (* d1 d2) d3)))>
#<alt (* d3 (+ d1 (/ (* d1 d2) d3)))>
#<alt (* d3 (+ d1 (/ (* d1 d2) d3)))>
#<alt (* d1 d3)>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))>
#<alt (* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* d1 (+ d2 d3))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 d3))))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 d3))))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 d3))))>
#<alt (* -1 (* d1 (+ (* -1 d2) (* -1 d3))))>
#<alt (* d1 d3)>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (+ (* d1 d2) (* d1 d3))>
#<alt (* d1 d2)>
#<alt (* d2 (+ d1 (/ (* d1 d3) d2)))>
#<alt (* d2 (+ d1 (/ (* d1 d3) d2)))>
#<alt (* d2 (+ d1 (/ (* d1 d3) d2)))>
#<alt (* d1 d2)>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))>
#<alt (* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d3)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 d2)>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* d1 (+ 3 d3))>
#<alt (* -1 (* d1 (- (* -1 d3) 3)))>
#<alt (* -1 (* d1 (- (* -1 d3) 3)))>
#<alt (* -1 (* d1 (- (* -1 d3) 3)))>
#<alt (* -1 (* d1 (- (* -1 d3) 3)))>
#<alt (* 3 d1)>
#<alt (+ (* 3 d1) (* d1 d3))>
#<alt (+ (* 3 d1) (* d1 d3))>
#<alt (+ (* 3 d1) (* d1 d3))>
#<alt (* d1 d3)>
#<alt (* d3 (+ d1 (* 3 (/ d1 d3))))>
#<alt (* d3 (+ d1 (* 3 (/ d1 d3))))>
#<alt (* d3 (+ d1 (* 3 (/ d1 d3))))>
#<alt (* d1 d3)>
#<alt (* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))>
#<alt (* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))>
#<alt (* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))>

Calls

33 calls:

Time	Variable		Point	Expression
0.0ms	d1	@	-inf	(+ (* d1 3) (* d3 d1))
0.0ms	d1	@	inf	(+ (* d1 3) (* d3 d1))
0.0ms	d1	@	0	(+ (* d1 3) (* d3 d1))
0.0ms	d3	@	-inf	(+ (* d1 3) (* d3 d1))
0.0ms	d3	@	inf	(+ (* d1 3) (* d3 d1))

rewrite12.0ms (0.3%)

Algorithm

1×	batch-egg-rewrite

Rules

20×	`-lowering-.f32`
20×	`-lowering-.f64`
16×	`fma-lowering-fma.f32`
16×	`fma-define`
16×	`+-lowering-+.f64`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	10	21
1	16	19
2	30	19
3	32	19
0	32	19

Stop Event

1×	iter limit
1×	saturated

Counts

5 → 22

Calls

Call 1

Inputs
(* d1 d3)
(+ (* d3 d1) (* d1 d2))
(* d3 d1)
(* d1 d2)
(+ (* d1 3) (* d3 d1))

Outputs
(*.f64 d1 d3)
(*.f64 d3 d1)
(+.f64 (.f64 d1 d3) (.f64 d1 d2))
(+.f64 (.f64 d1 d2) (.f64 d1 d3))
(fma.f64 d1 d3 (*.f64 d1 d2))
(fma.f64 d1 d2 (*.f64 d1 d3))
(fma.f64 d3 d1 (*.f64 d1 d2))
(fma.f64 d2 d1 (*.f64 d1 d3))
(*.f64 d1 (+.f64 d3 d2))
(*.f64 (+.f64 d3 d2) d1)
(*.f64 d1 d3)
(*.f64 d3 d1)
(*.f64 d1 d2)
(*.f64 d2 d1)
(+.f64 (.f64 d1 d3) (.f64 d1 #s(literal 3 binary64)))
(+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d3))
(fma.f64 d1 d3 (*.f64 d1 #s(literal 3 binary64)))
(fma.f64 d1 #s(literal 3 binary64) (*.f64 d1 d3))
(fma.f64 d3 d1 (*.f64 d1 #s(literal 3 binary64)))
(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 d3))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(*.f64 (+.f64 d3 #s(literal 3 binary64)) d1)

simplify107.0ms (3%)

Algorithm

1×	egg-herbie

Rules

2226×	`fnmadd-define`
2022×	`fnmsub-define`
1562×	`-lowering-.f32`
1562×	`-lowering-.f64`
1024×	`sum4-define`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	46	498
1	161	498
2	481	498
3	1274	498
4	4041	498
0	8497	498

Stop Event

1×	iter limit
1×	node limit

Counts

132 → 132

Calls

Call 1

Inputs
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d2)
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(* d1 d3)
(* d3 (+ d1 (/ (* d1 d2) d3)))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(* d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* d1 (+ d2 d3))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(* d1 d3)
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(+ (* d1 d2) (* d1 d3))
(* d1 d2)
(* d2 (+ d1 (/ (* d1 d3) d2)))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(* d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d3)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 d2)
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* d1 (+ 3 d3))
(* -1 (* d1 (- (* -1 d3) 3)))
(* -1 (* d1 (- (* -1 d3) 3)))
(* -1 (* d1 (- (* -1 d3) 3)))
(* -1 (* d1 (- (* -1 d3) 3)))
(* 3 d1)
(+ (* 3 d1) (* d1 d3))
(+ (* 3 d1) (* d1 d3))
(+ (* 3 d1) (* d1 d3))
(* d1 d3)
(* d3 (+ d1 (* 3 (/ d1 d3))))
(* d3 (+ d1 (* 3 (/ d1 d3))))
(* d3 (+ d1 (* 3 (/ d1 d3))))
(* d1 d3)
(* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))
(* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))
(* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))

Outputs
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d2)
(*.f64 d1 d2)
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d3 d2))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d3 d2))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d3 d2))
(* d1 d3)
(*.f64 d1 d3)
(* d3 (+ d1 (/ (* d1 d2) d3)))
(*.f64 d1 (+.f64 d3 d2))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(*.f64 d1 (+.f64 d3 d2))
(* d3 (+ d1 (/ (* d1 d2) d3)))
(*.f64 d1 (+.f64 d3 d2))
(* d1 d3)
(*.f64 d1 d3)
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(*.f64 d1 (+.f64 d3 d2))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(*.f64 d1 (+.f64 d3 d2))
(* -1 (* d3 (+ (* -1 d1) (* -1 (/ (* d1 d2) d3)))))
(*.f64 d1 (+.f64 d3 d2))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d3 d2))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d3 d2))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d3 d2))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d3 d2))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d3 d2))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d3 d2))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d3 d2))
(* d1 (+ d2 d3))
(*.f64 d1 (+.f64 d3 d2))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(*.f64 d1 (+.f64 d3 d2))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(*.f64 d1 (+.f64 d3 d2))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(*.f64 d1 (+.f64 d3 d2))
(* -1 (* d1 (+ (* -1 d2) (* -1 d3))))
(*.f64 d1 (+.f64 d3 d2))
(* d1 d3)
(*.f64 d1 d3)
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d3 d2))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d3 d2))
(+ (* d1 d2) (* d1 d3))
(*.f64 d1 (+.f64 d3 d2))
(* d1 d2)
(*.f64 d1 d2)
(* d2 (+ d1 (/ (* d1 d3) d2)))
(*.f64 d1 (+.f64 d3 d2))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(*.f64 d1 (+.f64 d3 d2))
(* d2 (+ d1 (/ (* d1 d3) d2)))
(*.f64 d1 (+.f64 d3 d2))
(* d1 d2)
(*.f64 d1 d2)
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(*.f64 d1 (+.f64 d3 d2))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(*.f64 d1 (+.f64 d3 d2))
(* -1 (* d2 (+ (* -1 d1) (* -1 (/ (* d1 d3) d2)))))
(*.f64 d1 (+.f64 d3 d2))
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d3)
(*.f64 d1 d3)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 d2)
(*.f64 d1 d2)
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* d1 (+ 3 d3))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* -1 (* d1 (- (* -1 d3) 3)))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* -1 (* d1 (- (* -1 d3) 3)))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* -1 (* d1 (- (* -1 d3) 3)))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* -1 (* d1 (- (* -1 d3) 3)))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* 3 d1)
(*.f64 d1 #s(literal 3 binary64))
(+ (* 3 d1) (* d1 d3))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(+ (* 3 d1) (* d1 d3))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(+ (* 3 d1) (* d1 d3))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* d1 d3)
(*.f64 d1 d3)
(* d3 (+ d1 (* 3 (/ d1 d3))))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* d3 (+ d1 (* 3 (/ d1 d3))))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* d3 (+ d1 (* 3 (/ d1 d3))))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* d1 d3)
(*.f64 d1 d3)
(* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))
(* -1 (* d3 (+ (* -3 (/ d1 d3)) (* -1 d1))))
(*.f64 d1 (+.f64 d3 #s(literal 3 binary64)))

eval17.0ms (0.5%)

Compiler: Compiled 979 to 30 computations (96.9% saved)

prune9.0ms (0.3%)

Pruning

13 alts after pruning (0 fresh and 13 done)

	Pruned	Kept	Total
New	180	0	180
Fresh	0	0	0
Picked	0	3	3
Done	0	10	10
Total	180	13	193

Accuracy

100.0%

Counts

193 → 13

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	99.2%	(fma.f64 (+.f64 #s(literal 3 binary64) d3) d1 (*.f64 d1 d2))
✓	81.6%	(fma.f64 d3 d1 (*.f64 d1 d2))
✓	80.8%	(fma.f64 d2 d1 (*.f64 d3 d1))
✓	57.2%	(fma.f64 d1 #s(literal 3 binary64) (*.f64 d3 d1))
✓	63.1%	(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 d2))
✓	80.0%	(+.f64 (.f64 d3 d1) (.f64 d1 d2))
✓	99.9%	(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))
✓	82.4%	(*.f64 d1 (+.f64 d2 d3))
✓	63.1%	(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
✓	57.1%	(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
✓	40.7%	(*.f64 d1 d3)
✓	45.1%	(*.f64 d1 d2)
✓	19.7%	(*.f64 d1 #s(literal 3 binary64))

Compiler

Compiled 208 to 98 computations (52.9% saved)

regimes24.0ms (0.7%)

Counts

16 → 1

Calls

Call 1

Inputs
(*.f64 d1 #s(literal 3 binary64))
(*.f64 d1 d2)
(*.f64 d1 d3)
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(*.f64 d1 (+.f64 d2 d3))
(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))
(+.f64 (.f64 d1 d2) (.f64 d1 d3))
(+.f64 (.f64 d3 d1) (.f64 d1 d2))
(+.f64 (+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d2)) (*.f64 d1 d3))
(fma.f64 #s(literal 3 binary64) d1 (*.f64 d1 d2))
(fma.f64 d1 #s(literal 3 binary64) (*.f64 d3 d1))
(fma.f64 d2 d1 (*.f64 d3 d1))
(fma.f64 d3 d1 (*.f64 d1 d2))
(fma.f64 (+.f64 #s(literal 3 binary64) d3) d1 (*.f64 d1 d2))
(fma.f64 (+.f64 d2 #s(literal 3 binary64)) d1 (*.f64 d1 d3))

Outputs
(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))

Calls

4 calls:

8.0ms	d1
5.0ms	d3
5.0ms	d2
5.0ms	(+.f64 (+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d2)) (*.f64 d1 d3))

Results

Accuracy	Segments	Branch
99.9%	1	`d1`
99.9%	1	`d2`
99.9%	1	`d3`
99.9%	1	`(+.f64 (+.f64 (.f64 d1 #s(literal 3 binary64)) (.f64 d1 d2)) (*.f64 d1 d3))`

Compiler

Compiled 26 to 18 computations (30.8% saved)

regimes9.0ms (0.2%)

Counts

6 → 2

Calls

Call 1

Inputs
(*.f64 d1 #s(literal 3 binary64))
(*.f64 d1 d2)
(*.f64 d1 d3)
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(*.f64 d1 (+.f64 d2 d3))

Outputs
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(*.f64 d1 (+.f64 d2 d3))

Calls

3 calls:

3.0ms	d1
3.0ms	d2
3.0ms	d3

Results

Accuracy	Segments	Branch
82.4%	1	`d1`
98.9%	2	`d2`
98.9%	2	`d3`

Compiler

Compiled 12 to 9 computations (25% saved)

regimes7.0ms (0.2%)

Counts

5 → 2

Calls

Call 1

Inputs
(*.f64 d1 #s(literal 3 binary64))
(*.f64 d1 d2)
(*.f64 d1 d3)
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))

Outputs
(*.f64 d1 (+.f64 d2 #s(literal 3 binary64)))
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))

Calls

2 calls:

4.0ms	d2
3.0ms	d3

Results

Accuracy	Segments	Branch
95.6%	2	`d2`
92.9%	2	`d3`

Compiler

Compiled 8 to 6 computations (25% saved)

regimes3.0ms (0.1%)

Counts

4 → 2

Calls

Call 1

Inputs
(*.f64 d1 #s(literal 3 binary64))
(*.f64 d1 d2)
(*.f64 d1 d3)
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))

Outputs
(*.f64 d1 d2)
(*.f64 d1 (+.f64 #s(literal 3 binary64) d3))

Calls

1 calls:

2.0ms

d2

Results

Accuracy	Segments	Branch
94.9%	2	`d2`

Compiler

Compiled 4 to 3 computations (25% saved)

regimes6.0ms (0.2%)

Counts

3 → 2

Calls

Call 1

Inputs
(*.f64 d1 #s(literal 3 binary64))
(*.f64 d1 d2)
(*.f64 d1 d3)

Outputs
(*.f64 d1 d2)
(*.f64 d1 d3)

Calls

3 calls:

2.0ms	d1
2.0ms	d3
2.0ms	d2

Results

Accuracy	Segments	Branch
51.9%	3	`d1`
75.5%	2	`d3`
78.2%	2	`d2`

Compiler

Compiled 12 to 9 computations (25% saved)

regimes3.0ms (0.1%)

Counts

2 → 2

Calls

Call 1

Inputs
(*.f64 d1 #s(literal 3 binary64))
(*.f64 d1 d2)

Outputs
(*.f64 d1 d2)
(*.f64 d1 #s(literal 3 binary64))

Calls

2 calls:

2.0ms	d3
2.0ms	d2

Results

Accuracy	Segments	Branch
45.1%	1	`d3`
61.7%	2	`d2`

Compiler

Compiled 8 to 6 computations (25% saved)

regimes4.0ms (0.1%)

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

1 → 1

Calls

Call 1

Inputs
(*.f64 d1 #s(literal 3 binary64))

Outputs
(*.f64 d1 #s(literal 3 binary64))

Calls

3 calls:

1.0ms	d2
1.0ms	d3
1.0ms	d1

Results

Accuracy	Segments	Branch
19.7%	1	`d3`
19.7%	1	`d1`
19.7%	1	`d2`

Compiler

Compiled 12 to 9 computations (25% saved)

bsearch15.0ms (0.4%)

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
14.0ms	1.352754669176478e-6	0.022006692557143076

Results

10.0ms

128×

valid

Compiler

Compiled 164 to 118 computations (28% saved)

Precisions

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

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

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

const: 0.0ms (0% of total)

backward-pass: 0.0ms (0% of total)

bsearch10.0ms (0.3%)

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
10.0ms	-475863.4329809071	-104941.39370016241

Results

6.0ms

96×

valid

Compiler

Compiled 128 to 98 computations (23.4% saved)

Precisions

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

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

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

const: 0.0ms (0% of total)

backward-pass: 0.0ms (0% of total)

bsearch12.0ms (0.3%)

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
11.0ms	-475863.4329809071	-104941.39370016241

Results

8.0ms

96×

valid

Compiler

Compiled 116 to 86 computations (25.9% saved)

Precisions

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

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

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

const: 0.0ms (0% of total)

backward-pass: 0.0ms (0% of total)

bsearch10.0ms (0.3%)

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
9.0ms	-475863.4329809071	-104941.39370016241

Results

6.0ms

96×

valid

Compiler

Compiled 104 to 74 computations (28.8% saved)

Precisions

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

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

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

const: 0.0ms (0% of total)

backward-pass: 0.0ms (0% of total)

bsearch12.0ms (0.3%)

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
11.0ms	-475863.4329809071	-104941.39370016241

Results

8.0ms

96×

valid

Compiler

Compiled 104 to 80 computations (23.1% saved)

Precisions

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

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

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

const: 0.0ms (0% of total)

backward-pass: 0.0ms (0% of total)

simplify8.0ms (0.2%)

Algorithm

1×	egg-herbie

Rules

14×	`*-commutative_binary64`
8×	`+-commutative_binary64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	30	70
1	41	70

Stop Event

1×

saturated

Calls

Call 1

Inputs
(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))
(if (<=.f64 d3 #s(literal 3170534137668829/144115188075855872 binary64)) (.f64 d1 (+.f64 d2 #s(literal 3 binary64))) (.f64 d1 (+.f64 d2 d3)))
(if (<=.f64 d2 #s(literal -162000 binary64)) (.f64 d1 (+.f64 d2 #s(literal 3 binary64))) (.f64 d1 (+.f64 #s(literal 3 binary64) d3)))
(if (<=.f64 d2 #s(literal -330000 binary64)) (.f64 d1 d2) (.f64 d1 (+.f64 #s(literal 3 binary64) d3)))
(if (<=.f64 d2 #s(literal -470000 binary64)) (.f64 d1 d2) (.f64 d1 d3))
(if (<=.f64 d2 #s(literal -105000 binary64)) (.f64 d1 d2) (.f64 d1 #s(literal 3 binary64)))
(*.f64 d1 #s(literal 3 binary64))

Outputs
(*.f64 d1 (+.f64 d2 (+.f64 #s(literal 3 binary64) d3)))
(if (<=.f64 d3 #s(literal 3170534137668829/144115188075855872 binary64)) (.f64 d1 (+.f64 d2 #s(literal 3 binary64))) (.f64 d1 (+.f64 d2 d3)))
(if (<=.f64 d2 #s(literal -162000 binary64)) (.f64 d1 (+.f64 d2 #s(literal 3 binary64))) (.f64 d1 (+.f64 #s(literal 3 binary64) d3)))
(if (<=.f64 d2 #s(literal -330000 binary64)) (.f64 d1 d2) (.f64 d1 (+.f64 #s(literal 3 binary64) d3)))
(if (<=.f64 d2 #s(literal -470000 binary64)) (.f64 d1 d2) (.f64 d1 d3))
(if (<=.f64 d2 #s(literal -105000 binary64)) (.f64 d1 d2) (.f64 d1 #s(literal 3 binary64)))
(*.f64 d1 #s(literal 3 binary64))

soundness870.0ms (24.1%)

Rules

3062×	`-lowering-.f32`
3062×	`-lowering-.f64`
2330×	`-lowering-.f32`
2330×	`-lowering-.f64`
1732×	`fnmadd-define`

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	111	1010
1	422	950
2	1142	950
3	3649	950
0	8151	950
0	9	9
1	20	7
2	47	6
3	79	6
4	94	6
5	96	6
0	96	6
0	99	816
1	349	738
2	936	738
3	2944	738
4	7981	738
0	8670	738

Stop Event

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

Compiler

Compiled 285 to 181 computations (36.5% saved)

preprocess53.0ms (1.5%)

Remove

(sort d2 d3)

(negabs d1)

Compiler

Compiled 274 to 148 computations (46% saved)

analyze0.0ms (0%)

sample968.0ms (26.8%)

preprocess82.0ms (2.3%)

explain117.0ms (3.2%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify8.0ms (0.2%)

localize165.0ms (4.6%)

series111.0ms (3.1%)

rewrite27.0ms (0.7%)

simplify160.0ms (4.4%)

eval21.0ms (0.6%)

prune12.0ms (0.3%)

simplify7.0ms (0.2%)

localize113.0ms (3.1%)

series12.0ms (0.3%)

rewrite14.0ms (0.4%)

simplify162.0ms (4.5%)

eval32.0ms (0.9%)

prune13.0ms (0.4%)

simplify5.0ms (0.1%)

localize116.0ms (3.2%)

series3.0ms (0.1%)

rewrite11.0ms (0.3%)

simplify155.0ms (4.3%)

eval24.0ms (0.7%)

prune7.0ms (0.2%)

simplify5.0ms (0.1%)

localize62.0ms (1.7%)

series2.0ms (0%)

rewrite12.0ms (0.3%)

simplify107.0ms (3%)

eval17.0ms (0.5%)

prune9.0ms (0.3%)

regimes24.0ms (0.7%)

regimes9.0ms (0.2%)

regimes7.0ms (0.2%)

regimes3.0ms (0.1%)

regimes6.0ms (0.2%)

regimes3.0ms (0.1%)

regimes4.0ms (0.1%)

bsearch15.0ms (0.4%)

bsearch10.0ms (0.3%)

bsearch12.0ms (0.3%)

bsearch10.0ms (0.3%)

bsearch12.0ms (0.3%)

simplify8.0ms (0.2%)

soundness870.0ms (24.1%)

preprocess53.0ms (1.5%)

end0.0ms (0%)

Profiling