Metrics for math.exp on complex, imaginary part

start0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

analyze0.0ms (0%)

Memory

0.3MiB live, 0.3MiB allocated

Algorithm

1×

Search

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

Compiler

Compiled 7 to 7 computations (0% saved)

sample971.0ms (6%)

Memory

23.6MiB live, 1 023.6MiB allocated

Samples

724.0ms

8 256×

valid

Precisions

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

ival-sin: 310.0ms (58% of total)

ival-exp: 141.0ms (26.4% of total)

ival-mult: 75.0ms (14% of total)

ival-true: 6.0ms (1.1% of total)

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

Bogosity

explain68.0ms (0.4%)

Memory

6.8MiB live, 123.9MiB allocated

FPErrors

Click to see full error table

Example	Example	Subexpression
-	-	`(*.f64 (exp.f64 re) (sin.f64 im))`
-	-	`(sin.f64 im)`
-	-	`re`
-	-	`(exp.f64 re)`
-	-	`im`

Confusion

	Predicted +	Predicted -
+	0	0
-	0	256

Precision

0/0

Recall

0/0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	0	0	0
-	0	0	256

Precision?

0/0

Recall?

0/0

Freqs

test

number	freq
0	256

Total Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	0	0	0
-	0	0	1

Precision?

0/0

Recall?

0/0

Samples

34.0ms

512×

valid

Compiler

Compiled 46 to 24 computations (47.8% saved)

Precisions

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

ival-sin: 12.0ms (54.2% of total)

ival-exp: 7.0ms (31.6% of total)

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

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

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

preprocess26.0ms (0.2%)

Memory

-26.8MiB live, 50.5MiB allocated

Algorithm

1×	egg-herbie

Rules

60×	`associate-r`
52×	`unsub-neg`
48×	`associate-l`
42×	`distribute-lft-neg-in`
38×	`sub-neg`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	15	31
1	38	29
2	77	27
3	148	27
4	281	27
5	428	27
6	451	27
7	465	27
8	472	27
9	472	27
0	5	5
0	8	5
1	9	5
0	9	5

Stop Event

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

Calls

Call 1

Inputs
(*.f64 (exp.f64 re) (sin.f64 im))

Outputs
(*.f64 (exp.f64 re) (sin.f64 im))

Symmetry

(negabs im)

Compiler

Compiled 7 to 5 computations (28.6% saved)

eval0.0ms (0%)

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

prune1.0ms (0%)

Memory

1.5MiB live, 1.5MiB allocated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	100.0%	(*.f64 (exp.f64 re) (sin.f64 im))

Compiler

Compiled 7 to 5 computations (28.6% saved)

simplify3.0ms (0%)

Memory

6.0MiB live, 6.0MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 3 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(sin.f64 im)
cost-diff	0	(exp.f64 re)
cost-diff	0	(*.f64 (exp.f64 re) (sin.f64 im))

Rules

4×	`lower-*.f32`
2×	`lift-sin.f64`
2×	`*-commutative`
2×	`lift-exp.f64`
2×	`lower-*.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	5	11
0	8	11
1	9	11
0	9	11

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(*.f64 (exp.f64 re) (sin.f64 im))
(exp.f64 re)
re
(sin.f64 im)
im

Outputs
(*.f64 (exp.f64 re) (sin.f64 im))
(exp.f64 re)
re
(sin.f64 im)
im

localize28.0ms (0.2%)

Memory

0.8MiB live, 43.1MiB allocated

Localize:

Found 3 expressions of interest:

New	Metric	Score
accuracy	0	(sin.f64 im)
accuracy	0	(exp.f64 re)
accuracy	0.01953125	(*.f64 (exp.f64 re) (sin.f64 im))

Samples

23.0ms

256×

valid

Compiler

Compiled 13 to 7 computations (46.2% saved)

Precisions

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

ival-sin: 6.0ms (61.7% of total)

ival-exp: 2.0ms (20.6% of total)

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

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

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

series3.0ms (0%)

Memory

5.5MiB live, 5.5MiB allocated

Counts

3 → 48

Calls

Call 1

Inputs
#<alt (*.f64 (exp.f64 re) (sin.f64 im))>
#<alt (exp.f64 re)>
#<alt (sin.f64 im)>

Outputs
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt im>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>

Calls

12 calls:

Time	Variable		Point	Expression
1.0ms	re	@	inf	(* (exp re) (sin im))
1.0ms	im	@	0	(* (exp re) (sin im))
0.0ms	re	@	0	(* (exp re) (sin im))
0.0ms	im	@	-inf	(* (exp re) (sin im))
0.0ms	im	@	inf	(* (exp re) (sin im))

simplify396.0ms (2.4%)

Memory

9.8MiB live, 685.2MiB allocated

Algorithm

1×	egg-herbie

Rules

15 566×	`lower-fma.f64`
15 566×	`lower-fma.f32`
4 310×	`lower-*.f64`
4 310×	`lower-*.f32`
2 896×	`lower--.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	71	297
1	221	286
2	586	274
3	1574	268
4	2436	268
5	3110	268
6	3581	268
7	3732	268
8	4021	268
9	5977	268
0	8264	246

Stop Event

1×	iter limit
1×	node limit

Counts

48 → 47

Calls

Call 1

Inputs
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
im
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)

Outputs
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (sin.f64 im) (+.f64 re #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 (exp.f64 re) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 im (.f64 im (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) #s(literal 1 binary64))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 im (.f64 im (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 re #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
im
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(fma.f64 (.f64 im im) (.f64 im (fma.f64 im (*.f64 im #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(fma.f64 (.f64 im im) (.f64 im (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)

rewrite16.0ms (0.1%)

Memory

-5.4MiB live, 34.1MiB allocated

Rules

4×	`lower-*.f32`
2×	`lift-sin.f64`
2×	`lift-exp.f64`
2×	`lower-*.f64`
2×	`lower-sin.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	5	9
0	8	9
1	9	9
0	9	9

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Counts

3 → 4

Calls

Call 1

Inputs
(*.f64 (exp.f64 re) (sin.f64 im))
(exp.f64 re)
(sin.f64 im)

Outputs
(*.f64 (exp.f64 re) (sin.f64 im))
(*.f64 (sin.f64 im) (exp.f64 re))
(exp.f64 re)
(sin.f64 im)

eval5.0ms (0%)

Memory: 10.7MiB live, 10.7MiB allocated
Compiler: Compiled 393 to 47 computations (88% saved)

prune17.0ms (0.1%)

Memory

-23.6MiB live, 15.7MiB allocated

Pruning

5 alts after pruning (5 fresh and 0 done)

	Pruned	Kept	Total
New	46	5	51
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	47	5	52

Accuracy

100.0%

Counts

52 → 5

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	61.4%	(.f64 (exp.f64 re) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
▶	69.1%	(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))
▶	54.7%	(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
▶	64.8%	#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
▶	53.9%	#s(approx (* (exp re) (sin im)) (sin.f64 im))

Compiler

Compiled 96 to 58 computations (39.6% saved)

simplify13.0ms (0.1%)

Memory

19.8MiB live, 19.7MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 17 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
cost-diff	0	#s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))
cost-diff	0	(exp.f64 re)
cost-diff	0	(.f64 (exp.f64 re) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
cost-diff	0	(sin.f64 im)
cost-diff	0	(+.f64 re #s(literal 1 binary64))
cost-diff	0	#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
cost-diff	0	(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
cost-diff	0	(exp.f64 re)
cost-diff	0	(*.f64 im (exp.f64 re))
cost-diff	0	#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
cost-diff	0	(sin.f64 im)
cost-diff	0	#s(approx (* (exp re) (sin im)) (sin.f64 im))
cost-diff	0	(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
cost-diff	0	(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
cost-diff	0	#s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
cost-diff	0	(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))

Rules

180×	`lower-*.f32`
168×	`lower-*.f64`
104×	`lower-fma.f32`
98×	`lower-fma.f64`
58×	`associate-r`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	25	138
0	42	138
1	67	138
2	94	135
3	123	135
4	134	135
5	137	135
6	164	135
7	164	135
8	176	135
9	176	135
10	188	135
11	188	135
0	188	132

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))
#s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
re
(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
#s(literal 1/2 binary64)
#s(literal 1 binary64)
(sin.f64 im)
im
#s(approx (* (exp re) (sin im)) (sin.f64 im))
(sin.f64 im)
im
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
(*.f64 im (exp.f64 re))
im
(exp.f64 re)
re
(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(+.f64 re #s(literal 1 binary64))
re
#s(literal 1 binary64)
(sin.f64 im)
im
(.f64 (exp.f64 re) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(exp.f64 re)
re
#s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
im
(.f64 #s(literal -1/6 binary64) (.f64 im im))
#s(literal -1/6 binary64)
(*.f64 im im)

Outputs
(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))
#s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
re
(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
#s(literal 1/2 binary64)
#s(literal 1 binary64)
(sin.f64 im)
im
#s(approx (* (exp re) (sin im)) (sin.f64 im))
(sin.f64 im)
im
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
(*.f64 im (exp.f64 re))
im
(exp.f64 re)
re
(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
(*.f64 (sin.f64 im) #s(approx (exp re) (+.f64 re #s(literal 1 binary64))))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(+.f64 re #s(literal 1 binary64))
re
#s(literal 1 binary64)
(sin.f64 im)
im
(.f64 (exp.f64 re) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(.f64 (exp.f64 re) #s(approx (sin im) (fma.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im)) im)))
(exp.f64 re)
re
#s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))
#s(approx (sin im) (fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im)
im
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(.f64 im (.f64 im #s(literal -1/6 binary64)))
#s(literal -1/6 binary64)
(*.f64 im im)

localize142.0ms (0.9%)

Memory

-9.8MiB live, 159.2MiB allocated

Localize:

Found 17 expressions of interest:

New	Metric	Score
accuracy	0.01953125	(.f64 (exp.f64 re) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
accuracy	0.046875	(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
accuracy	0.1640625	(.f64 #s(literal -1/6 binary64) (.f64 im im))
accuracy	31.39460396768176	#s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))
accuracy	0	(+.f64 re #s(literal 1 binary64))
accuracy	0	(sin.f64 im)
accuracy	0.01953125	(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
accuracy	28.936626058771207	#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
accuracy	0	(exp.f64 re)
accuracy	0.0078125	(*.f64 im (exp.f64 re))
accuracy	22.529110259401293	#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
accuracy	0	(sin.f64 im)
accuracy	29.518157205544824	#s(approx (* (exp re) (sin im)) (sin.f64 im))
accuracy	0	(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
accuracy	0	(sin.f64 im)
accuracy	0.01953125	(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))
accuracy	19.793355940614703	#s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))

Samples

94.0ms

256×

valid

Compiler

Compiled 94 to 20 computations (78.7% saved)

Precisions

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

ival-mult: 61.0ms (77.9% of total)

ival-sin: 6.0ms (7.7% of total)

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

const: 3.0ms (3.8% of total)

ival-exp: 2.0ms (2.6% of total)

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

exact: 0.0ms (0% of total)

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

series30.0ms (0.2%)

Memory

-23.7MiB live, 18.1MiB allocated

Counts

16 → 264

Calls

Call 1

Inputs
#<alt (*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))>
#<alt #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))>
#<alt (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))>
#<alt (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))>
#<alt #s(approx (* (exp re) (sin im)) (sin.f64 im))>
#<alt (sin.f64 im)>
#<alt #s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))>
#<alt (*.f64 im (exp.f64 re))>
#<alt (exp.f64 re)>
#<alt (*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))>
#<alt #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))>
#<alt (+.f64 re #s(literal 1 binary64))>
#<alt (.f64 (exp.f64 re) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))>
#<alt #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))>
#<alt (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)>
#<alt (.f64 #s(literal -1/6 binary64) (.f64 im im))>

Outputs
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (* 1/2 (pow re 2))>
#<alt (* (pow re 2) (+ 1/2 (/ 1 re)))>
#<alt (* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))>
#<alt (* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))>
#<alt (* 1/2 (pow re 2))>
#<alt (* (pow re 2) (+ 1/2 (/ 1 re)))>
#<alt (* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))>
#<alt (* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))>
#<alt 1>
#<alt (+ 1 (* 1/2 re))>
#<alt (+ 1 (* 1/2 re))>
#<alt (+ 1 (* 1/2 re))>
#<alt (* 1/2 re)>
#<alt (* re (+ 1/2 (/ 1 re)))>
#<alt (* re (+ 1/2 (/ 1 re)))>
#<alt (* re (+ 1/2 (/ 1 re)))>
#<alt (* 1/2 re)>
#<alt (* re (+ 1/2 (/ 1 re)))>
#<alt (* re (+ 1/2 (/ 1 re)))>
#<alt (* re (+ 1/2 (/ 1 re)))>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt im>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt im>
#<alt (+ im (* im re))>
#<alt (+ im (* re (+ im (* 1/2 (* im re)))))>
#<alt (+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 re)>
#<alt (+ 1 re)>
#<alt re>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt re>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt im>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt im>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* -1/6 (pow im 3))>
#<alt (* (pow im 3) (- (/ 1 (pow im 2)) 1/6))>
#<alt (* (pow im 3) (- (/ 1 (pow im 2)) 1/6))>
#<alt (* (pow im 3) (- (/ 1 (pow im 2)) 1/6))>
#<alt (* -1/6 (pow im 3))>
#<alt (* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))>
#<alt (* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))>
#<alt (* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>

Calls

66 calls:

Time	Variable		Point	Expression
1.0ms	re	@	-inf	(+ (* re (+ (* re 1/2) 1)) 1)
0.0ms	im	@	inf	(+ (* im (* -1/6 (* im im))) im)
0.0ms	re	@	inf	(+ (* re (+ (* re 1/2) 1)) 1)
0.0ms	im	@	inf	(* -1/6 (* im im))
0.0ms	im	@	inf	(* im (exp re))

simplify388.0ms (2.4%)

Memory

14.3MiB live, 841.7MiB allocated

Algorithm

1×	egg-herbie

Rules

17 002×	`lower-fma.f64`
17 002×	`lower-fma.f32`
4 954×	`lower-*.f64`
4 954×	`lower-*.f32`
2 780×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	106	1649
1	328	1560
2	859	1528
3	2724	1498
4	5687	1498
5	7319	1498
0	8141	1378

Stop Event

1×	iter limit
1×	node limit

Counts

264 → 258

Calls

Call 1

Inputs
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* 1/2 re))))
(* 1/2 (pow re 2))
(* (pow re 2) (+ 1/2 (/ 1 re)))
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(* 1/2 (pow re 2))
(* (pow re 2) (+ 1/2 (/ 1 re)))
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
1
(+ 1 (* 1/2 re))
(+ 1 (* 1/2 re))
(+ 1 (* 1/2 re))
(* 1/2 re)
(* re (+ 1/2 (/ 1 re)))
(* re (+ 1/2 (/ 1 re)))
(* re (+ 1/2 (/ 1 re)))
(* 1/2 re)
(* re (+ 1/2 (/ 1 re)))
(* re (+ 1/2 (/ 1 re)))
(* re (+ 1/2 (/ 1 re)))
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
im
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
im
(+ im (* im re))
(+ im (* re (+ im (* 1/2 (* im re)))))
(+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
1
(+ 1 re)
(+ 1 re)
(+ 1 re)
re
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
re
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
im
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
im
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* -1/6 (pow im 2))))
(* -1/6 (pow im 3))
(* (pow im 3) (- (/ 1 (pow im 2)) 1/6))
(* (pow im 3) (- (/ 1 (pow im 2)) 1/6))
(* (pow im 3) (- (/ 1 (pow im 2)) 1/6))
(* -1/6 (pow im 3))
(* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))
(* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))
(* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))

Outputs
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (sin.f64 im) (+.f64 re #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 im (*.f64 im #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 re #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 re #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(* 1/2 (pow re 2))
(.f64 re (.f64 re #s(literal 1/2 binary64)))
(* (pow re 2) (+ 1/2 (/ 1 re)))
(fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(* 1/2 (pow re 2))
(.f64 re (.f64 re #s(literal 1/2 binary64)))
(* (pow re 2) (+ 1/2 (/ 1 re)))
(fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
1
#s(literal 1 binary64)
(+ 1 (* 1/2 re))
(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
(+ 1 (* 1/2 re))
(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
(+ 1 (* 1/2 re))
(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))
(* re (+ 1/2 (/ 1 re)))
(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
(* re (+ 1/2 (/ 1 re)))
(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
(* re (+ 1/2 (/ 1 re)))
(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
(* 1/2 re)
(*.f64 re #s(literal 1/2 binary64))
(* re (+ 1/2 (/ 1 re)))
(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
(* re (+ 1/2 (/ 1 re)))
(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
(* re (+ 1/2 (/ 1 re)))
(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (sin.f64 im) (+.f64 re #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 im (*.f64 im #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
im
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (sin.f64 im) (+.f64 re #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 im (*.f64 im #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
im
(+ im (* im re))
(fma.f64 im re im)
(+ im (* re (+ im (* 1/2 (* im re)))))
(fma.f64 im (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re) im)
(+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))
(fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 re #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (sin.f64 im) (+.f64 re #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 im (*.f64 im #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 re #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 re #s(literal 1 binary64))
(+ 1 re)
(+.f64 re #s(literal 1 binary64))
(+ 1 re)
(+.f64 re #s(literal 1 binary64))
re
(* re (+ 1 (/ 1 re)))
(+.f64 re #s(literal 1 binary64))
(* re (+ 1 (/ 1 re)))
(+.f64 re #s(literal 1 binary64))
(* re (+ 1 (/ 1 re)))
(+.f64 re #s(literal 1 binary64))
re
(* re (+ 1 (/ 1 re)))
(+.f64 re #s(literal 1 binary64))
(* re (+ 1 (/ 1 re)))
(+.f64 re #s(literal 1 binary64))
(* re (+ 1 (/ 1 re)))
(+.f64 re #s(literal 1 binary64))
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (sin.f64 im) (+.f64 re #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 im (*.f64 im #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
im
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
im
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* -1/6 (pow im 3))
(.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im)))
(* (pow im 3) (- (/ 1 (pow im 2)) 1/6))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* (pow im 3) (- (/ 1 (pow im 2)) 1/6))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* (pow im 3) (- (/ 1 (pow im 2)) 1/6))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* -1/6 (pow im 3))
(.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im)))
(* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))

rewrite330.0ms (2%)

Memory

37.1MiB live, 713.3MiB allocated

Rules

7 944×	`lower-fma.f32`
7 938×	`lower-fma.f64`
4 568×	`lower-*.f32`
4 556×	`lower-*.f64`
2 692×	`lower-/.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	25	116
0	42	116
1	112	113
2	638	113
3	6255	113
0	8081	110

Stop Event

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

Counts

16 → 367

Calls

Call 1

Inputs
(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))
#s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
#s(approx (* (exp re) (sin im)) (sin.f64 im))
(sin.f64 im)
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
(*.f64 im (exp.f64 re))
(exp.f64 re)
(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(+.f64 re #s(literal 1 binary64))
(.f64 (exp.f64 re) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
#s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(.f64 #s(literal -1/6 binary64) (.f64 im im))

Outputs
(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))
(*.f64 (sin.f64 im) #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))))
#s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(+.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re))
(+.f64 (+.f64 re #s(literal 1 binary64)) (.f64 re (.f64 re #s(literal 1/2 binary64))))
(+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re) #s(literal 1 binary64))
(+.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))) (+.f64 re #s(literal 1 binary64)))
(+.f64 (/.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))) #s(literal -1 binary64)))
(-.f64 (/.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))))
(-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (/.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (-.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re))))
(-.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))))
(fma.f64 re #s(literal 1 binary64) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 re (*.f64 re #s(literal 1/2 binary64)) (+.f64 re #s(literal 1 binary64)))
(fma.f64 re (/.f64 (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 re re) (+.f64 re #s(literal 1 binary64)))
(fma.f64 #s(literal 1 binary64) re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(fma.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)) (.f64 re (.f64 re #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re) #s(literal 1 binary64))
(fma.f64 #s(literal 1 binary64) (.f64 re (.f64 re #s(literal 1/2 binary64))) (+.f64 re #s(literal 1 binary64)))
(fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) re #s(literal 1 binary64))
(fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (/.f64 (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(fma.f64 (+.f64 re #s(literal 1 binary64)) #s(literal 1 binary64) (.f64 re (.f64 re #s(literal 1/2 binary64))))
(fma.f64 (+.f64 re #s(literal 1 binary64)) (.f64 (+.f64 re #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))) (.f64 re (*.f64 re #s(literal 1/2 binary64))))
(fma.f64 (+.f64 re #s(literal 1 binary64)) (/.f64 (+.f64 re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))) (.f64 re (.f64 re #s(literal 1/2 binary64))))
(fma.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re) #s(literal 1 binary64) #s(literal 1 binary64))
(fma.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (/.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(fma.f64 (*.f64 re #s(literal 1/2 binary64)) re (+.f64 re #s(literal 1 binary64)))
(fma.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)) (.f64 re (*.f64 re #s(literal 1/2 binary64))))
(fma.f64 (*.f64 re re) #s(literal 1/2 binary64) (+.f64 re #s(literal 1 binary64)))
(fma.f64 (.f64 re re) (/.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(fma.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(fma.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64))) re) #s(literal 1 binary64))
(fma.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (/.f64 re (fma.f64 re (-.f64 (*.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64))) #s(literal 1 binary64))
(fma.f64 (fma.f64 re re #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))) (.f64 re (.f64 re #s(literal 1/2 binary64))))
(fma.f64 (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) re) #s(literal 1 binary64))
(fma.f64 (fma.f64 re (*.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) (/.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) #s(literal 1 binary64))
(fma.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))) #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))
(fma.f64 (neg.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))) (.f64 re (*.f64 re #s(literal 1/2 binary64))))
(fma.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)) (.f64 re (.f64 re #s(literal 1/2 binary64))))
(fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))) (fma.f64 re re #s(literal -1 binary64)) (.f64 re (.f64 re #s(literal 1/2 binary64))))
(fma.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64))) (.f64 re (.f64 re re))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (.f64 re (.f64 re #s(literal 1/2 binary64)))) (.f64 (.f64 re re) (.f64 re (*.f64 re #s(literal 1/4 binary64)))))) #s(literal 1 binary64))
(fma.f64 (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)) (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (.f64 re (*.f64 re #s(literal 1/2 binary64))))
(fma.f64 (.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))) #s(literal 1 binary64))
(fma.f64 (-.f64 #s(literal 1 binary64) (.f64 re re)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)) (.f64 re (*.f64 re #s(literal 1/2 binary64))))
(fma.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))) (/.f64 (.f64 re re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(fma.f64 (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (/.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(fma.f64 (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)))) (/.f64 re (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(fma.f64 (fma.f64 re (.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64))) re) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64))) #s(literal 1 binary64))
(fma.f64 (.f64 re (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) #s(literal 1 binary64))
(fma.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re re #s(literal -1 binary64))) (+.f64 re #s(literal 1 binary64)) (.f64 re (.f64 re #s(literal 1/2 binary64))))
(fma.f64 (/.f64 (-.f64 #s(literal 1 binary64) (.f64 re re)) (-.f64 #s(literal 1 binary64) (.f64 re re))) (+.f64 re #s(literal 1 binary64)) (.f64 re (.f64 re #s(literal 1/2 binary64))))
(fma.f64 (/.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (fma.f64 (-.f64 #s(literal 1 binary64) re) (.f64 (-.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 1 binary64) re)) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))))) (fma.f64 (-.f64 #s(literal 1 binary64) re) (-.f64 (-.f64 #s(literal 1 binary64) re) (.f64 re re)) (.f64 re (.f64 re (.f64 re re)))) (.f64 re (*.f64 re #s(literal 1/2 binary64))))
(fma.f64 (/.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re) (+.f64 (fma.f64 re re #s(literal -1 binary64)) re))) (+.f64 (fma.f64 re re #s(literal -1 binary64)) re) (.f64 re (.f64 re #s(literal 1/2 binary64))))
(fma.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (+.f64 (fma.f64 re re #s(literal 1 binary64)) re) (.f64 re (*.f64 re #s(literal 1/2 binary64))))
(fma.f64 (/.f64 (-.f64 #s(literal 1 binary64) (.f64 re re)) (-.f64 #s(literal 1 binary64) (.f64 re (.f64 re re)))) (+.f64 (fma.f64 re re #s(literal 1 binary64)) re) (.f64 re (*.f64 re #s(literal 1/2 binary64))))
(fma.f64 (/.f64 (fma.f64 re (.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64))) re) (fma.f64 (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)) (.f64 (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)) (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1/64 binary64)))) (fma.f64 (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)) (-.f64 (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 re #s(literal 1/4 binary64)))) (.f64 (.f64 re (.f64 re (.f64 re re))) #s(literal 1/16 binary64))) #s(literal 1 binary64))
(fma.f64 (/.f64 (fma.f64 re (.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64))) re) (.f64 (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (+.f64 (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) (.f64 re #s(literal 1/2 binary64))))) (+.f64 (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) (*.f64 re #s(literal 1/2 binary64))) #s(literal 1 binary64))
(fma.f64 (/.f64 (.f64 re (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64))) (fma.f64 re (*.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 (/.f64 (.f64 re (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64))) (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal -1 binary64))) (fma.f64 re (fma.f64 re #s(literal 1/4 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 (/.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(fma.f64 (/.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64))) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) re) #s(literal 1 binary64)) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(neg.f64 (/.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64)) (neg.f64 (fma.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64)))))
(neg.f64 (/.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64)) (-.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re))))
(neg.f64 (/.f64 (neg.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64))) (fma.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64))))
(neg.f64 (/.f64 (neg.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))))))
(/.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64)) (fma.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64)))
(/.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64)) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))
(/.f64 (neg.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64))) (neg.f64 (fma.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64))))
(/.f64 (neg.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64))) (-.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)))
(/.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) #s(literal 9 binary64))) (.f64 (fma.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64)) (-.f64 (fma.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))))))))
(/.f64 (fma.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64)) (.f64 (fma.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64)) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64))))
(/.f64 (fma.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64)) (.f64 (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)) #s(literal 1 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(/.f64 (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))
(/.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64)) (.f64 (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)) #s(literal 1 binary64))))
(/.f64 (-.f64 (.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (.f64 (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64))) (.f64 (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))))
(/.f64 (.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) #s(literal 9 binary64))) #s(literal 1 binary64)) (.f64 (-.f64 (fma.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))))) (fma.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64)) #s(literal 1 binary64)) (.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64)) (fma.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64)) #s(literal 1 binary64)) (.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) #s(literal 1 binary64))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))))
(/.f64 (.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64)) #s(literal 1 binary64)) (.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) #s(literal 1 binary64)) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))))) (neg.f64 (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64)))) (neg.f64 (neg.f64 (fma.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64)))) (neg.f64 (-.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re))))
(/.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64))) (pow.f64 (+.f64 re #s(literal 1 binary64)) #s(literal 3 binary64))) (fma.f64 (.f64 re re) (.f64 re (.f64 re #s(literal 1/4 binary64))) (-.f64 (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))) (.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))) (+.f64 re #s(literal 1 binary64))))))
(/.f64 (+.f64 (pow.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 3 binary64)) (.f64 re (.f64 re re))) (fma.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) (-.f64 (.f64 re re) (.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal -3 binary64))) (fma.f64 (/.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (.f64 (/.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))))
(/.f64 (-.f64 (.f64 (.f64 re re) (.f64 re (.f64 re #s(literal 1/4 binary64)))) (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64)))) (-.f64 (.f64 re (*.f64 re #s(literal 1/2 binary64))) (+.f64 re #s(literal 1 binary64))))
(/.f64 (-.f64 (.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))) (.f64 re re)) (-.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))))) (fma.f64 (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)))) (/.f64 re (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(/.f64 (.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64)) #s(literal 1 binary64)) (fma.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64)))
(/.f64 (.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64)) #s(literal 1 binary64)) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))
(/.f64 (.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) #s(literal 9 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64)))) (-.f64 (fma.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))))))
(/.f64 (.f64 (fma.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64)))) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64)))
(/.f64 (.f64 (fma.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)) #s(literal 1 binary64))))
(/.f64 (.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)) #s(literal 1 binary64)))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(*.f64 (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(.f64 (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)) (.f64 (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(*.f64 (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)) (/.f64 (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))))
(.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64))))
(.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))))
(.f64 (neg.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64)))))
(.f64 (neg.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))))
(.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64))) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64))) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64)))
(.f64 (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re))))
(.f64 (/.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64)) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(.f64 (/.f64 (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re))))) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(.f64 (/.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64)) (fma.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))))) (.f64 (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (.f64 (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))))) (fma.f64 (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (-.f64 (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) (.f64 (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))))))
(.f64 (/.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal 1 binary64)) (.f64 (fma.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64)) (fma.f64 (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) (fma.f64 (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal -1 binary64)) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)))
(.f64 (/.f64 (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) #s(literal -1 binary64)) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) #s(literal -1 binary64))) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) re) #s(literal 1 binary64)))
(.f64 (/.f64 (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))) (-.f64 #s(literal 1 binary64) (.f64 re (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))))))) (fma.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) re) #s(literal 1 binary64)))
(+.f64 #s(literal 1 binary64) (*.f64 re #s(literal 1/2 binary64)))
(+.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))
(+.f64 (/.f64 (.f64 re (.f64 re #s(literal 1/4 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)))) #s(literal -1 binary64)))
(-.f64 (/.f64 (.f64 re (.f64 re #s(literal 1/4 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))))
(-.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64))) (/.f64 (.f64 re (.f64 re #s(literal 1/4 binary64))) (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64))))
(fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/4 binary64)) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))
(fma.f64 #s(literal 1/2 binary64) re #s(literal 1 binary64))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))
(fma.f64 #s(literal 1 binary64) (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))
(fma.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64) #s(literal 1 binary64))
(fma.f64 (.f64 re #s(literal 1/2 binary64)) (/.f64 (.f64 re #s(literal 1/2 binary64)) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/4 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))
(fma.f64 (.f64 re (.f64 re #s(literal 1/4 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))
(fma.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))) (/.f64 #s(literal 1/2 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))
(fma.f64 #s(literal 1/4 binary64) (/.f64 (*.f64 re re) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))
(fma.f64 (*.f64 re #s(literal 1/4 binary64)) (/.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))
(fma.f64 (/.f64 (.f64 re (.f64 re #s(literal 1/4 binary64))) (fma.f64 re (*.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))
(fma.f64 (/.f64 (.f64 re (.f64 re #s(literal 1/4 binary64))) (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal -1 binary64))) (fma.f64 re (fma.f64 re #s(literal 1/4 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))
(neg.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (neg.f64 (fma.f64 re (-.f64 (*.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64)))))
(neg.f64 (/.f64 (fma.f64 re (*.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64))))
(neg.f64 (/.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64))) (fma.f64 re (-.f64 (*.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64))))
(neg.f64 (/.f64 (neg.f64 (fma.f64 re (*.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)) (+.f64 #s(literal 1 binary64) (.f64 #s(literal -1/4 binary64) (.f64 re re)))))
(/.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (fma.f64 re (-.f64 (*.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(/.f64 (fma.f64 re (*.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))
(/.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64))) (neg.f64 (fma.f64 re (-.f64 (*.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64))))
(/.f64 (neg.f64 (fma.f64 re (*.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64))) (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)))
(/.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)))) #s(literal 1/512 binary64) #s(literal 1 binary64)) (.f64 (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (-.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1/64 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64))))))
(/.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1/64 binary64) #s(literal -1 binary64)) (.f64 (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (fma.f64 re (.f64 (*.f64 re re) #s(literal 1/8 binary64)) #s(literal -1 binary64))))
(/.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1/64 binary64) #s(literal -1 binary64)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)) (fma.f64 (.f64 re (.f64 re (.f64 re re))) #s(literal 1/16 binary64) (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal 1 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)))))
(/.f64 (+.f64 #s(literal 1 binary64) (.f64 #s(literal -1/4 binary64) (.f64 re re))) (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)))
(/.f64 (fma.f64 (.f64 re (.f64 re (.f64 re re))) #s(literal 1/16 binary64) #s(literal -1 binary64)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)) (fma.f64 re (*.f64 re #s(literal 1/4 binary64)) #s(literal 1 binary64))))
(/.f64 (-.f64 (.f64 (.f64 re (.f64 re #s(literal 1/4 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)) #s(literal 1 binary64))) (*.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))))
(/.f64 (.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)) (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(/.f64 (.f64 (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64)) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))
(/.f64 (.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64))) #s(literal 1 binary64)) (neg.f64 (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64))))
(/.f64 (.f64 (neg.f64 (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64)) (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)))
(/.f64 (.f64 (+.f64 #s(literal 1 binary64) (.f64 #s(literal -1/4 binary64) (*.f64 re re))) #s(literal 1 binary64)) (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)))
(/.f64 (.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)))) #s(literal 1/512 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)) (.f64 (-.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1/64 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)))) (fma.f64 re (-.f64 (*.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1/64 binary64) #s(literal -1 binary64)) #s(literal 1 binary64)) (.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal -1 binary64)) (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1/64 binary64) #s(literal -1 binary64)) #s(literal 1 binary64)) (.f64 (fma.f64 (.f64 re (.f64 re (.f64 re re))) #s(literal 1/16 binary64) (fma.f64 re (*.f64 re #s(literal 1/4 binary64)) #s(literal 1 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 re (.f64 re (.f64 re re))) #s(literal 1/16 binary64) #s(literal -1 binary64)) #s(literal 1 binary64)) (.f64 (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal 1 binary64)) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64)))) (neg.f64 (neg.f64 (fma.f64 re (-.f64 (*.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)))) (neg.f64 (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64))))
(/.f64 (neg.f64 (+.f64 #s(literal 1 binary64) (.f64 #s(literal -1/4 binary64) (.f64 re re)))) (neg.f64 (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 re (.f64 re #s(literal 1/4 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)) #s(literal -3 binary64))) (fma.f64 (/.f64 (.f64 re (.f64 re #s(literal 1/4 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (/.f64 (.f64 re (.f64 re #s(literal 1/4 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (.f64 (/.f64 (.f64 re (*.f64 re #s(literal 1/4 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re #s(literal 1/4 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (/.f64 (.f64 re (.f64 re #s(literal 1/4 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))))) (fma.f64 (*.f64 re re) (/.f64 #s(literal 1/4 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))
(/.f64 (.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)))) #s(literal 1/512 binary64) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64)))) (-.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1/64 binary64) #s(literal 1 binary64)) (.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)))))
(/.f64 (.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1/64 binary64) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64)))) (fma.f64 re (.f64 (*.f64 re re) #s(literal 1/8 binary64)) #s(literal -1 binary64)))
(/.f64 (.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1/64 binary64) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))) (fma.f64 (.f64 re (.f64 re (.f64 re re))) #s(literal 1/16 binary64) (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal 1 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 re (.f64 re (.f64 re re))) #s(literal 1/16 binary64) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))) (fma.f64 re (*.f64 re #s(literal 1/4 binary64)) #s(literal 1 binary64)))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)) (+.f64 #s(literal 1 binary64) (.f64 #s(literal -1/4 binary64) (.f64 re re)))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)))
(*.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)))))
(*.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) (/.f64 (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64)) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))))
(.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64))))
(.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 (*.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64))) #s(literal 1 binary64)))
(.f64 (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))))
(.f64 (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) #s(literal 1 binary64)))
(.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64)))))
(.f64 (neg.f64 (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64))))
(.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/2 binary64) #s(literal -1 binary64))) (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64))) (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64)))
(.f64 (+.f64 #s(literal 1 binary64) (.f64 #s(literal -1/4 binary64) (*.f64 re re))) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64))))
(.f64 (/.f64 (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) (fma.f64 re (*.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64))) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)))
(.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (fma.f64 (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)) (.f64 (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)) (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1/64 binary64)))) (fma.f64 (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)) (-.f64 (fma.f64 re #s(literal -1/2 binary64) #s(literal 1 binary64)) (.f64 re (.f64 re #s(literal 1/4 binary64)))) (.f64 (.f64 re (.f64 re (.f64 re re))) #s(literal 1/16 binary64))))
(.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (.f64 (fma.f64 re (-.f64 (.f64 re #s(literal 1/4 binary64)) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (+.f64 (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) (.f64 re #s(literal 1/2 binary64))))) (+.f64 (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) (*.f64 re #s(literal 1/2 binary64))))
(.f64 (/.f64 (fma.f64 re (.f64 re #s(literal 1/4 binary64)) #s(literal -1 binary64)) (fma.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64)) #s(literal -1 binary64))) (fma.f64 re (fma.f64 re #s(literal 1/4 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(.f64 (/.f64 (+.f64 #s(literal 1 binary64) (.f64 #s(literal -1/4 binary64) (.f64 re re))) (-.f64 #s(literal 1 binary64) (.f64 re (.f64 (.f64 re re) #s(literal 1/8 binary64))))) (fma.f64 re (fma.f64 re #s(literal 1/4 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)))
(.f64 (/.f64 (+.f64 #s(literal 1 binary64) (.f64 #s(literal -1/4 binary64) (.f64 re re))) (+.f64 #s(literal 1 binary64) (.f64 #s(literal -1/4 binary64) (*.f64 re re)))) (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)))
#s(approx (* (exp re) (sin im)) (sin.f64 im))
(sin.f64 im)
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
(*.f64 im (exp.f64 re))
(*.f64 (exp.f64 re) im)
(exp.f64 re)
(exp.f64 (*.f64 (log.f64 (exp.f64 re)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal 1 binary64))) re))
(pow.f64 (exp.f64 re) #s(literal 1 binary64))
(pow.f64 (exp.f64 #s(literal 1 binary64)) re)
(pow.f64 (pow.f64 (exp.f64 #s(literal 1 binary64)) #s(literal 1 binary64)) re)
(*.f64 (sin.f64 im) #s(approx (exp re) (+.f64 re #s(literal 1 binary64))))
(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(+.f64 re #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) re)
(+.f64 (/.f64 (*.f64 re re) (+.f64 re #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))) #s(literal -1 binary64)))
(-.f64 (/.f64 (*.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))))
(-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)) (/.f64 (*.f64 re re) (-.f64 #s(literal 1 binary64) re)))
(fma.f64 re #s(literal 1 binary64) #s(literal 1 binary64))
(fma.f64 re (/.f64 re (+.f64 re #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))))
(fma.f64 #s(literal 1 binary64) re #s(literal 1 binary64))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))))
(fma.f64 (/.f64 (*.f64 re re) (fma.f64 re re #s(literal -1 binary64))) (+.f64 re #s(literal 1 binary64)) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))))
(fma.f64 (/.f64 (.f64 re re) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (+.f64 (fma.f64 re re #s(literal 1 binary64)) re) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))))
(neg.f64 (/.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64)) (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))))
(neg.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (-.f64 #s(literal 1 binary64) re)))
(neg.f64 (/.f64 (neg.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(neg.f64 (/.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64))) (+.f64 re #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 1 binary64) (*.f64 re re))))
(/.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64)) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))
(/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))
(/.f64 (neg.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64))) (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(/.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64))) (-.f64 #s(literal 1 binary64) re))
(/.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1 binary64)) (.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re) (-.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)) #s(literal 1 binary64)) (.f64 re (.f64 re re)))))
(/.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)) #s(literal -1 binary64)) (.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re) (fma.f64 re (.f64 re re) #s(literal -1 binary64))))
(/.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)) #s(literal -1 binary64)) (.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 (.f64 re re) (*.f64 re re) (fma.f64 re re #s(literal 1 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
(/.f64 (-.f64 #s(literal 1 binary64) (*.f64 re re)) (-.f64 #s(literal 1 binary64) re))
(/.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) (*.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64))))
(/.f64 (-.f64 (.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (.f64 (+.f64 re #s(literal -1 binary64)) #s(literal 1 binary64))) (.f64 (+.f64 re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1 binary64)) #s(literal 1 binary64)) (.f64 (-.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)) #s(literal 1 binary64)) (.f64 re (*.f64 re re))) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(/.f64 (.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)) #s(literal -1 binary64)) #s(literal 1 binary64)) (.f64 (fma.f64 re (*.f64 re re) #s(literal -1 binary64)) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(/.f64 (.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)) #s(literal -1 binary64)) #s(literal 1 binary64)) (.f64 (fma.f64 (.f64 re re) (.f64 re re) (fma.f64 re re #s(literal 1 binary64))) (+.f64 re #s(literal -1 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) #s(literal 1 binary64)) (.f64 (fma.f64 re re #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (*.f64 re re))) (neg.f64 (-.f64 #s(literal 1 binary64) re)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64)))) (neg.f64 (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64)))) (neg.f64 (-.f64 #s(literal 1 binary64) re)))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (+.f64 re #s(literal -1 binary64)) #s(literal -3 binary64))) (fma.f64 (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))) (.f64 (/.f64 (*.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64)))) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))))) (fma.f64 re (/.f64 re (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))))
(/.f64 (.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) #s(literal 1 binary64)) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))
(/.f64 (*.f64 (fma.f64 re re #s(literal -1 binary64)) #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64)))
(/.f64 (.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))) (-.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)) #s(literal 1 binary64)) (.f64 re (.f64 re re))))
(/.f64 (.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))) (fma.f64 re (.f64 re re) #s(literal -1 binary64)))
(/.f64 (.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))) (fma.f64 (.f64 re re) (*.f64 re re) (fma.f64 re re #s(literal 1 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 re re) (*.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))) (fma.f64 re re #s(literal 1 binary64)))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 1 binary64) (*.f64 re re))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))
(*.f64 (+.f64 re #s(literal 1 binary64)) #s(literal 1 binary64))
(.f64 (+.f64 re #s(literal 1 binary64)) (.f64 (+.f64 re #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))))
(*.f64 (+.f64 re #s(literal 1 binary64)) (/.f64 (+.f64 re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))
(.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(*.f64 (fma.f64 re re #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))))
(.f64 (neg.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))))
(*.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))) (fma.f64 re re #s(literal -1 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)) (fma.f64 re (.f64 re re) #s(literal 1 binary64)))
(.f64 (-.f64 #s(literal 1 binary64) (.f64 re re)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)))
(*.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re re #s(literal -1 binary64))) (+.f64 re #s(literal 1 binary64)))
(.f64 (/.f64 (-.f64 #s(literal 1 binary64) (.f64 re re)) (-.f64 #s(literal 1 binary64) (*.f64 re re))) (+.f64 re #s(literal 1 binary64)))
(.f64 (/.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (fma.f64 (-.f64 #s(literal 1 binary64) re) (.f64 (-.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 1 binary64) re)) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))))) (fma.f64 (-.f64 #s(literal 1 binary64) re) (-.f64 (-.f64 #s(literal 1 binary64) re) (.f64 re re)) (.f64 re (.f64 re (.f64 re re)))))
(.f64 (/.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (*.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re) (+.f64 (fma.f64 re re #s(literal -1 binary64)) re))) (+.f64 (fma.f64 re re #s(literal -1 binary64)) re))
(.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (+.f64 (fma.f64 re re #s(literal 1 binary64)) re))
(.f64 (/.f64 (-.f64 #s(literal 1 binary64) (.f64 re re)) (-.f64 #s(literal 1 binary64) (.f64 re (.f64 re re)))) (+.f64 (fma.f64 re re #s(literal 1 binary64)) re))
(.f64 (exp.f64 re) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(.f64 #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)) (exp.f64 re))
#s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))
(+.f64 im (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))
(+.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))) im)
(+.f64 (/.f64 (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (neg.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im)))))
(exp.f64 (.f64 (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im))) #s(literal -1 binary64)))
(-.f64 (/.f64 (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im))))
(-.f64 (/.f64 (.f64 im im) (+.f64 im (.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64)))) (/.f64 (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (+.f64 im (.f64 (.f64 im (*.f64 im im)) #s(literal 1/6 binary64)))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(fma.f64 im (/.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (neg.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)))))
(fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im)
(fma.f64 (.f64 im im) (.f64 im #s(literal -1/6 binary64)) im)
(fma.f64 (.f64 im im) (/.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (neg.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)))))
(fma.f64 (.f64 #s(literal -1/6 binary64) (.f64 im im)) im im)
(fma.f64 (.f64 #s(literal -1/6 binary64) (.f64 im im)) (/.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im (.f64 im im)))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (neg.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im)))))
(fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (/.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (neg.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im)))))
(fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)
(fma.f64 (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (neg.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im)))))
(fma.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im (.f64 im im)))) (/.f64 (.f64 #s(literal -1/6 binary64) (.f64 im im)) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (neg.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im)))))
(fma.f64 (.f64 im #s(literal -1/6 binary64)) (.f64 im im) im)
(fma.f64 (.f64 im #s(literal -1/6 binary64)) (/.f64 (.f64 (.f64 im im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (neg.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im)))))
(fma.f64 (pow.f64 im #s(literal 3/2 binary64)) (*.f64 (pow.f64 im #s(literal 3/2 binary64)) #s(literal -1/6 binary64)) im)
(fma.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (neg.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)))))
(fma.f64 (.f64 (.f64 im im) #s(literal 1/36 binary64)) (/.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (neg.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)))))
(fma.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) (/.f64 im (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (neg.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)))))
(fma.f64 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 im #s(literal 1/2 binary64)) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))
(fma.f64 (*.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 3/2 binary64))) (pow.f64 im #s(literal 3/2 binary64)) im)
(fma.f64 (/.f64 (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im) (neg.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im)))))
(fma.f64 (/.f64 (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (fma.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (neg.f64 im)) im))) (fma.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) (.f64 im (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (neg.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im)))))
(neg.f64 (/.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im))) (neg.f64 (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im)))))
(neg.f64 (/.f64 (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im)) (fma.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64) (neg.f64 (neg.f64 im)))))
(neg.f64 (/.f64 (neg.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im)))) (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im))))
(neg.f64 (/.f64 (neg.f64 (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 im (.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64))) (.f64 im (-.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (*.f64 im im) #s(literal 1/36 binary64))))))))
(/.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im))) (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im)))
(/.f64 (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im)) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im)))) (neg.f64 (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im))))
(/.f64 (neg.f64 (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im))) (fma.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64) (neg.f64 (neg.f64 im))))
(/.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (pow.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) #s(literal 9 binary64))) (.f64 (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im)) (fma.f64 (.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 im (.f64 im im)) (-.f64 (.f64 im (.f64 im im)) (.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (*.f64 im im)))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))))
(/.f64 (.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im))) (fma.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (neg.f64 im)) im))) (.f64 (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im)) (fma.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (neg.f64 im)) im))))
(/.f64 (.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im))) (fma.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (neg.f64 im)) im))) (.f64 (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (fma.f64 im (.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))))) (.f64 (.f64 im im) (.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)) #s(literal 1 binary64)) (*.f64 im im))))))
(/.f64 (.f64 im (-.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))))) (+.f64 im (.f64 (.f64 im (*.f64 im im)) #s(literal 1/6 binary64))))
(/.f64 (.f64 (.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)) #s(literal 1 binary64)) (.f64 im im)) (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im))) (.f64 (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)) #s(literal 1 binary64)) (.f64 im im))))
(/.f64 (-.f64 (.f64 (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (.f64 (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im))) (.f64 (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))))
(/.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (pow.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) #s(literal 9 binary64))) #s(literal 1 binary64)) (.f64 (fma.f64 (.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 im (.f64 im im)) (-.f64 (.f64 im (.f64 im im)) (.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im))))
(/.f64 (.f64 (.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im))) (fma.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (neg.f64 im)) im))) #s(literal 1 binary64)) (.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (neg.f64 im)) im)) (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (*.f64 im im))))
(/.f64 (.f64 (.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im))) (fma.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (neg.f64 im)) im))) #s(literal 1 binary64)) (.f64 (fma.f64 im (.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))))) (.f64 (.f64 im im) (.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)) #s(literal 1 binary64)) (.f64 im im)))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))))
(/.f64 (.f64 (.f64 (.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)) #s(literal 1 binary64)) (.f64 im im)) (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im))) #s(literal 1 binary64)) (.f64 (.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)) #s(literal 1 binary64)) (.f64 im im)) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im))))
(/.f64 (neg.f64 (neg.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im))))) (neg.f64 (neg.f64 (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im)))))
(/.f64 (neg.f64 (neg.f64 (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im)))) (neg.f64 (fma.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64) (neg.f64 (neg.f64 im)))))
(/.f64 (neg.f64 (.f64 im (-.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))))) (neg.f64 (+.f64 im (.f64 (.f64 im (*.f64 im im)) #s(literal 1/6 binary64)))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (/.f64 (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (fma.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (.f64 (/.f64 (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im)))))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (/.f64 (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)))) (.f64 (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))))) (fma.f64 im (/.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (/.f64 (.f64 im im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)))))
(/.f64 (.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im))) #s(literal 1 binary64)) (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (*.f64 im im)))
(/.f64 (.f64 (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im)) #s(literal 1 binary64)) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im)))
(/.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (pow.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) #s(literal 9 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im)))) (fma.f64 (.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 im (.f64 im im)) (-.f64 (.f64 im (.f64 im im)) (.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (*.f64 im im))))))))
(/.f64 (.f64 (.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im))) (fma.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (neg.f64 im)) im))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im)))) (fma.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (neg.f64 im)) im)))
(/.f64 (.f64 (.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im))) (fma.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (neg.f64 im)) im))) (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)))) (fma.f64 im (.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))))) (.f64 (.f64 im im) (.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)) #s(literal 1 binary64)) (*.f64 im im)))))
(/.f64 (.f64 (.f64 (.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)) #s(literal 1 binary64)) (.f64 im im)) (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im))) (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)))) (.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)) #s(literal 1 binary64)) (.f64 im im)))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (+.f64 im (.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64))) (.f64 im (-.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (*.f64 im im) #s(literal 1/36 binary64))))))) #s(literal -1 binary64))
(.f64 #s(literal 1 binary64) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im))
(.f64 im (fma.f64 im (.f64 im #s(literal -1/6 binary64)) #s(literal 1 binary64)))
(.f64 (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im) (.f64 (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)))))
(.f64 (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im) (/.f64 (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im))))
(.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (*.f64 im im))))
(.f64 (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im)) (.f64 (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im)))))
(.f64 (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im)) (/.f64 (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im) (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (*.f64 im im))))
(.f64 (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im)) (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) (neg.f64 im))))
(.f64 (neg.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (*.f64 im im)))))
(.f64 (neg.f64 (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im (*.f64 im im)) #s(literal 1/6 binary64) (neg.f64 (neg.f64 im)))))
(.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im))) (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (*.f64 im im))))
(.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im))) (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (*.f64 im im) #s(literal 1/36 binary64)))) im)))
(.f64 (.f64 im (-.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))))) (/.f64 #s(literal 1 binary64) (+.f64 im (.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64)))))
(.f64 (fma.f64 im (.f64 im #s(literal -1/6 binary64)) #s(literal 1 binary64)) im)
(.f64 (/.f64 (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im)) (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im))
(.f64 (/.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im))) (fma.f64 (.f64 im (+.f64 im (.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64)))) (.f64 (.f64 im im) (.f64 (+.f64 im (.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64))) (+.f64 im (.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64))))) (.f64 (.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (fma.f64 im (.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))))) (.f64 (.f64 im (+.f64 im (.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64)))) (-.f64 (.f64 im (+.f64 im (.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64)))) (.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))))))))
(.f64 (/.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) #s(literal 1 binary64)) (.f64 im (.f64 im im))) (.f64 (fma.f64 (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im))) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) (neg.f64 im)) (.f64 im im)) (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) (+.f64 im (.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64))))))) (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) (+.f64 im (.f64 (.f64 im (.f64 im im)) #s(literal 1/6 binary64))))))
(.f64 (/.f64 (.f64 im (-.f64 (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) im)) (fma.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/216 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (neg.f64 im)) im))) (fma.f64 im (.f64 im (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) (.f64 im (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im))))
(.f64 im (.f64 im #s(literal -1/6 binary64)))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(.f64 (.f64 im im) #s(literal -1/6 binary64))
(.f64 (.f64 im #s(literal -1/6 binary64)) im)

eval78.0ms (0.5%)

Memory: -9.7MiB live, 183.7MiB allocated
Compiler: Compiled 14 684 to 1 353 computations (90.8% saved)

prune67.0ms (0.4%)

Memory

3.4MiB live, 174.5MiB allocated

Pruning

18 alts after pruning (14 fresh and 4 done)

	Pruned	Kept	Total
New	653	14	667
Fresh	0	0	0
Picked	1	4	5
Done	0	0	0
Total	654	18	672

Accuracy

100.0%

Counts

672 → 18

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	69.1%	(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))
	39.3%	(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
	69.0%	(*.f64 #s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (sin.f64 im))
▶	69.1%	(.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im))
✓	54.7%	(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
▶	30.3%	(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
	33.7%	(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
✓	64.8%	#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
▶	38.7%	#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
	38.3%	#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
	29.0%	#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
▶	26.5%	#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
✓	53.9%	#s(approx (* (exp re) (sin im)) (sin.f64 im))
	38.4%	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
	29.0%	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
	29.6%	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)))
	33.8%	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
▶	33.4%	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))

Compiler

Compiled 454 to 243 computations (46.5% saved)

simplify31.0ms (0.2%)

Memory

-12.6MiB live, 70.8MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 19 expressions of interest:

New	Metric	Score
cost-diff	0	#s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im))
cost-diff	0	(+.f64 re #s(literal 1 binary64))
cost-diff	0	#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
cost-diff	0	(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
cost-diff	0	(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
cost-diff	0	#s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
cost-diff	0	(*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))
cost-diff	0	#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
cost-diff	0	(.f64 #s(literal -1/6 binary64) (.f64 im im))
cost-diff	0	(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
cost-diff	0	#s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))
cost-diff	0	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
cost-diff	0	#s(approx (exp re) #s(literal 1 binary64))
cost-diff	0	(*.f64 im #s(approx (exp re) #s(literal 1 binary64)))
cost-diff	0	#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
cost-diff	0	(fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))
cost-diff	0	#s(approx (exp re) (+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re))
cost-diff	0	(.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im))
cost-diff	128	(+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)

Rules

764×	`lower-fma.f32`
750×	`lower-fma.f64`
430×	`lower-*.f32`
414×	`lower-*.f64`
184×	`lower-+.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	37	273
0	63	265
1	114	262
2	185	262
3	322	262
4	472	262
5	521	262
6	597	262
7	597	262
0	597	256

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im))
#s(approx (exp re) (+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re))
(+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)
(fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))
re
(*.f64 re #s(literal 1/2 binary64))
#s(literal 1/2 binary64)
#s(literal 1 binary64)
(sin.f64 im)
im
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
(*.f64 im #s(approx (exp re) #s(literal 1 binary64)))
im
#s(approx (exp re) #s(literal 1 binary64))
#s(literal 1 binary64)
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
im
(.f64 #s(literal -1/6 binary64) (.f64 im im))
#s(literal -1/6 binary64)
(*.f64 im im)
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))
im
#s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
re
(fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
#s(literal 1/6 binary64)
#s(literal 1/2 binary64)
#s(literal 1 binary64)
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(+.f64 re #s(literal 1 binary64))
re
#s(literal 1 binary64)
#s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(*.f64 im im)
im
#s(literal 1/120 binary64)
#s(literal -1/6 binary64)
(.f64 im (.f64 im im))

Outputs
(.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im))
(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))
#s(approx (exp re) (+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re))
#s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))
re
(*.f64 re #s(literal 1/2 binary64))
#s(literal 1/2 binary64)
#s(literal 1 binary64)
(sin.f64 im)
im
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
(*.f64 im #s(approx (exp re) #s(literal 1 binary64)))
im
#s(approx (exp re) #s(literal 1 binary64))
#s(literal 1 binary64)
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im im) (.f64 im #s(literal -1/6 binary64)) im)))
#s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))
#s(approx (sin im) (fma.f64 (.f64 im im) (.f64 im #s(literal -1/6 binary64)) im))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(fma.f64 (.f64 im im) (.f64 im #s(literal -1/6 binary64)) im)
im
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(.f64 im (.f64 im #s(literal -1/6 binary64)))
#s(literal -1/6 binary64)
(*.f64 im im)
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))
im
#s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
re
(fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
#s(literal 1/6 binary64)
#s(literal 1/2 binary64)
#s(literal 1 binary64)
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)))) im)))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(+.f64 re #s(literal 1 binary64))
re
#s(literal 1 binary64)
#s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im))
#s(approx (sin im) (fma.f64 im (.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)))) im))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)
(fma.f64 im (.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)))) im)
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(*.f64 im im)
im
#s(literal 1/120 binary64)
#s(literal -1/6 binary64)
(.f64 im (.f64 im im))

localize126.0ms (0.8%)

Memory

4.7MiB live, 240.6MiB allocated

Localize:

Found 19 expressions of interest:

New	Metric	Score
accuracy	0.06640625	(.f64 im (.f64 im im))
accuracy	0.078125	(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
accuracy	28.936626058771207	#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
accuracy	31.374354038378968	#s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im))
accuracy	0.06640625	(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
accuracy	0.15625	(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
accuracy	18.133113674950557	#s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
accuracy	22.529110259401293	#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
accuracy	0.046875	(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
accuracy	0.1640625	(.f64 #s(literal -1/6 binary64) (.f64 im im))
accuracy	29.518157205544824	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
accuracy	31.39460396768176	#s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))
accuracy	0.0078125	(*.f64 im #s(approx (exp re) #s(literal 1 binary64)))
accuracy	22.529110259401293	#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
accuracy	29.67659491854943	#s(approx (exp re) #s(literal 1 binary64))
accuracy	0	(sin.f64 im)
accuracy	0.01953125	(+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)
accuracy	0.01953125	(.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im))
accuracy	19.793355940614703	#s(approx (exp re) (+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re))

Samples

64.0ms

256×

valid

Compiler

Compiled 163 to 33 computations (79.8% saved)

Precisions

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

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

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

const: 10.0ms (21.6% of total)

ival-sin: 6.0ms (12.9% of total)

ival-exp: 2.0ms (4.3% of total)

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

exact: 0.0ms (0% of total)

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

series37.0ms (0.2%)

Memory

-23.4MiB live, 18.6MiB allocated

Counts

23 → 360

Calls

Call 1

Inputs
#<alt (+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)>
#<alt (.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im))>
#<alt #s(approx (exp re) (+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re))>
#<alt (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))>
#<alt #s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))>
#<alt (*.f64 im #s(approx (exp re) #s(literal 1 binary64)))>
#<alt #s(approx (exp re) #s(literal 1 binary64))>
#<alt #s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))>
#<alt #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))>
#<alt (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)>
#<alt (.f64 #s(literal -1/6 binary64) (.f64 im im))>
#<alt #s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))>
#<alt (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))>
#<alt #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))>
#<alt (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))>
#<alt (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))>
#<alt #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))>
#<alt (+.f64 re #s(literal 1 binary64))>
#<alt #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im))>
#<alt (sin.f64 im)>
#<alt (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))>
#<alt (fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))>
#<alt (.f64 im (.f64 im im))>

Outputs
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (* 1/2 (pow re 2))>
#<alt (* (pow re 2) (+ 1/2 (/ 1 re)))>
#<alt (* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))>
#<alt (* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))>
#<alt (* 1/2 (pow re 2))>
#<alt (* (pow re 2) (+ 1/2 (/ 1 re)))>
#<alt (* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))>
#<alt (* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt 1>
#<alt (+ 1 (* 1/2 (pow re 2)))>
#<alt (+ 1 (* 1/2 (pow re 2)))>
#<alt (+ 1 (* 1/2 (pow re 2)))>
#<alt (* 1/2 (pow re 2))>
#<alt (* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))>
#<alt (* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))>
#<alt (* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))>
#<alt (* 1/2 (pow re 2))>
#<alt (* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))>
#<alt (* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))>
#<alt (* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt im>
#<alt (+ im (* im re))>
#<alt (+ im (* re (+ im (* 1/2 (* im re)))))>
#<alt (+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt im>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt im>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* -1/6 (pow im 3))>
#<alt (* (pow im 3) (- (/ 1 (pow im 2)) 1/6))>
#<alt (* (pow im 3) (- (/ 1 (pow im 2)) 1/6))>
#<alt (* (pow im 3) (- (/ 1 (pow im 2)) 1/6))>
#<alt (* -1/6 (pow im 3))>
#<alt (* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))>
#<alt (* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))>
#<alt (* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (* -1/6 (pow im 2))>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt im>
#<alt (+ im (* im re))>
#<alt (+ im (* re (+ im (* 1/2 (* im re)))))>
#<alt (+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))>
#<alt (* 1/6 (pow re 3))>
#<alt (* (pow re 3) (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* (pow re 3) (+ 1/6 (+ (* 1/2 (/ 1 re)) (/ 1 (pow re 2)))))>
#<alt (* (pow re 3) (+ 1/6 (+ (* 1/2 (/ 1 re)) (+ (/ 1 (pow re 2)) (/ 1 (pow re 3))))))>
#<alt (* 1/6 (pow re 3))>
#<alt (* (pow re 3) (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* -1 (* (pow re 3) (- (* -1 (/ (+ 1/2 (/ 1 re)) re)) 1/6)))>
#<alt (* -1 (* (pow re 3) (- (* -1 (/ (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))) re)) 1/6)))>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 re)>
#<alt (+ 1 re)>
#<alt re>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt re>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt im>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt im>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt 1/2>
#<alt (+ 1/2 (* 1/6 re))>
#<alt (+ 1/2 (* 1/6 re))>
#<alt (+ 1/2 (* 1/6 re))>
#<alt (* 1/6 re)>
#<alt (* re (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* re (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* re (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* 1/6 re)>
#<alt (* re (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* re (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* re (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt -1/6>
#<alt (- (* 1/120 (pow im 2)) 1/6)>
#<alt (- (* 1/120 (pow im 2)) 1/6)>
#<alt (- (* 1/120 (pow im 2)) 1/6)>
#<alt (* 1/120 (pow im 2))>
#<alt (* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))>
#<alt (* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))>
#<alt (* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))>
#<alt (* 1/120 (pow im 2))>
#<alt (* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))>
#<alt (* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))>
#<alt (* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>

Calls

90 calls:

Time	Variable		Point	Expression
1.0ms	re	@	-inf	(+ (* re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1)
0.0ms	im	@	-inf	(* im (* im im))
0.0ms	re	@	inf	(+ (* re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1)
0.0ms	im	@	inf	(+ (* (* im im) 1/120) -1/6)
0.0ms	re	@	inf	(+ (* re (* re 1/2)) 1)

simplify1.0s (6.2%)

Memory

-0.8MiB live, 603.9MiB allocated

Algorithm

1×	egg-herbie

Rules

19 234×	`lower-fma.f64`
19 234×	`lower-fma.f32`
5 750×	`lower-*.f64`
5 750×	`lower-*.f32`
2 440×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	135	2161
1	427	2066
2	1198	2024
3	4225	1994
4	7847	1994
0	8069	1822

Stop Event

1×	iter limit
1×	node limit

Counts

360 → 352

Calls

Call 1

Inputs
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* 1/2 re))))
(* 1/2 (pow re 2))
(* (pow re 2) (+ 1/2 (/ 1 re)))
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(* 1/2 (pow re 2))
(* (pow re 2) (+ 1/2 (/ 1 re)))
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
1
(+ 1 (* 1/2 (pow re 2)))
(+ 1 (* 1/2 (pow re 2)))
(+ 1 (* 1/2 (pow re 2)))
(* 1/2 (pow re 2))
(* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))
(* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))
(* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))
(* 1/2 (pow re 2))
(* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))
(* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))
(* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
im
(+ im (* im re))
(+ im (* re (+ im (* 1/2 (* im re)))))
(+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
im
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
im
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* -1/6 (pow im 2))))
(* -1/6 (pow im 3))
(* (pow im 3) (- (/ 1 (pow im 2)) 1/6))
(* (pow im 3) (- (/ 1 (pow im 2)) 1/6))
(* (pow im 3) (- (/ 1 (pow im 2)) 1/6))
(* -1/6 (pow im 3))
(* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))
(* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))
(* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(* -1/6 (pow im 2))
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
im
(+ im (* im re))
(+ im (* re (+ im (* 1/2 (* im re)))))
(+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(* 1/6 (pow re 3))
(* (pow re 3) (+ 1/6 (* 1/2 (/ 1 re))))
(* (pow re 3) (+ 1/6 (+ (* 1/2 (/ 1 re)) (/ 1 (pow re 2)))))
(* (pow re 3) (+ 1/6 (+ (* 1/2 (/ 1 re)) (+ (/ 1 (pow re 2)) (/ 1 (pow re 3))))))
(* 1/6 (pow re 3))
(* (pow re 3) (+ 1/6 (* 1/2 (/ 1 re))))
(* -1 (* (pow re 3) (- (* -1 (/ (+ 1/2 (/ 1 re)) re)) 1/6)))
(* -1 (* (pow re 3) (- (* -1 (/ (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))) re)) 1/6)))
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
1
(+ 1 re)
(+ 1 re)
(+ 1 re)
re
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
re
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
im
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
im
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
1/2
(+ 1/2 (* 1/6 re))
(+ 1/2 (* 1/6 re))
(+ 1/2 (* 1/6 re))
(* 1/6 re)
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(* 1/6 re)
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
-1/6
(- (* 1/120 (pow im 2)) 1/6)
(- (* 1/120 (pow im 2)) 1/6)
(- (* 1/120 (pow im 2)) 1/6)
(* 1/120 (pow im 2))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(* 1/120 (pow im 2))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)

Outputs
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(* 1/2 (pow re 2))
(.f64 re (.f64 re #s(literal 1/2 binary64)))
(* (pow re 2) (+ 1/2 (/ 1 re)))
(fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(* 1/2 (pow re 2))
(.f64 re (.f64 re #s(literal 1/2 binary64)))
(* (pow re 2) (+ 1/2 (/ 1 re)))
(fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re)
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(* (pow re 2) (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (sin.f64 im) (+.f64 #s(literal 1 binary64) re))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 (exp.f64 re) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
1
#s(literal 1 binary64)
(+ 1 (* 1/2 (pow re 2)))
(fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))
(+ 1 (* 1/2 (pow re 2)))
(fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))
(+ 1 (* 1/2 (pow re 2)))
(fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))
(* 1/2 (pow re 2))
(.f64 re (.f64 re #s(literal 1/2 binary64)))
(* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))
(* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))
(* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))
(* 1/2 (pow re 2))
(.f64 re (.f64 re #s(literal 1/2 binary64)))
(* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))
(* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))
(* (pow re 2) (+ 1/2 (/ 1 (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (sin.f64 im) (+.f64 #s(literal 1 binary64) re))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 (exp.f64 re) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
im
(+ im (* im re))
(fma.f64 re im im)
(+ im (* re (+ im (* 1/2 (* im re)))))
(fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)
(+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))
(fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (sin.f64 im) (+.f64 #s(literal 1 binary64) re))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 (exp.f64 re) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
im
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(fma.f64 (.f64 im im) (.f64 im (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))) im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
im
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* -1/6 (pow im 3))
(.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)))
(* (pow im 3) (- (/ 1 (pow im 2)) 1/6))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* (pow im 3) (- (/ 1 (pow im 2)) 1/6))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* (pow im 3) (- (/ 1 (pow im 2)) 1/6))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* -1/6 (pow im 3))
(.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)))
(* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* -1 (* (pow im 3) (- 1/6 (/ 1 (pow im 2)))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(* -1/6 (pow im 2))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (sin.f64 im) (+.f64 #s(literal 1 binary64) re))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 (exp.f64 re) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
im
(+ im (* im re))
(fma.f64 re im im)
(+ im (* re (+ im (* 1/2 (* im re)))))
(fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)
(+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))
(fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(* 1/6 (pow re 3))
(.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))
(* (pow re 3) (+ 1/6 (* 1/2 (/ 1 re))))
(.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))
(* (pow re 3) (+ 1/6 (+ (* 1/2 (/ 1 re)) (/ 1 (pow re 2)))))
(fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)
(* (pow re 3) (+ 1/6 (+ (* 1/2 (/ 1 re)) (+ (/ 1 (pow re 2)) (/ 1 (pow re 3))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(* 1/6 (pow re 3))
(.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))
(* (pow re 3) (+ 1/6 (* 1/2 (/ 1 re))))
(.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))
(* -1 (* (pow re 3) (- (* -1 (/ (+ 1/2 (/ 1 re)) re)) 1/6)))
(fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)
(* -1 (* (pow re 3) (- (* -1 (/ (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))) re)) 1/6)))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (sin.f64 im) (+.f64 #s(literal 1 binary64) re))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 (exp.f64 re) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
re
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
re
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
im
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(fma.f64 (.f64 im im) (.f64 im (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))) im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
im
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(fma.f64 (.f64 im im) (.f64 im (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))) im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
1/2
#s(literal 1/2 binary64)
(+ 1/2 (* 1/6 re))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(+ 1/2 (* 1/6 re))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(+ 1/2 (* 1/6 re))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(* 1/6 re)
(*.f64 re #s(literal 1/6 binary64))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(* 1/6 re)
(*.f64 re #s(literal 1/6 binary64))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
-1/6
#s(literal -1/6 binary64)
(- (* 1/120 (pow im 2)) 1/6)
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(- (* 1/120 (pow im 2)) 1/6)
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(- (* 1/120 (pow im 2)) 1/6)
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(* 1/120 (pow im 2))
(.f64 (.f64 im im) #s(literal 1/120 binary64))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(* 1/120 (pow im 2))
(.f64 (.f64 im im) #s(literal 1/120 binary64))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))

rewrite678.0ms (4.2%)

Memory

-5.2MiB live, 355.5MiB allocated

Rules

9 492×	`lower-fma.f32`
9 478×	`lower-fma.f64`
4 280×	`lower-*.f32`
4 264×	`lower-*.f64`
3 958×	`lower-/.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	37	226
0	63	220
1	214	217
2	1462	217
0	8583	214

Stop Event

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

Counts

23 → 343

Calls

Call 1

Inputs
(+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)
(.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im))
#s(approx (exp re) (+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re))
(fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
(*.f64 im #s(approx (exp re) #s(literal 1 binary64)))
#s(approx (exp re) #s(literal 1 binary64))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))
(fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)
(.f64 #s(literal -1/6 binary64) (.f64 im im))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))
#s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(+.f64 re #s(literal 1 binary64))
#s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im))
(sin.f64 im)
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(.f64 im (.f64 im im))

Outputs
(+.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)))
(+.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)) re)
(+.f64 (+.f64 re #s(literal 1 binary64)) (.f64 #s(literal 1/2 binary64) (.f64 re re)))
(+.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (+.f64 re #s(literal 1 binary64)))
(+.f64 (/.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (neg.f64 (/.f64 (.f64 re re) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re))))
(+.f64 (+.f64 re (.f64 #s(literal 1/2 binary64) (.f64 re re))) #s(literal 1 binary64))
(+.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re) #s(literal 1 binary64))
(-.f64 (/.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (/.f64 (.f64 re re) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)))
(-.f64 (/.f64 (.f64 re re) (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)))) (/.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)))))
(-.f64 (/.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (-.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (+.f64 re #s(literal 1 binary64)))) (/.f64 (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))) (-.f64 (.f64 #s(literal 1/2 binary64) (*.f64 re re)) (+.f64 re #s(literal 1 binary64)))))
(fma.f64 re (*.f64 re #s(literal 1/2 binary64)) (+.f64 re #s(literal 1 binary64)))
(fma.f64 re #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)))
(fma.f64 #s(literal 1/2 binary64) (*.f64 re re) (+.f64 re #s(literal 1 binary64)))
(fma.f64 (*.f64 re #s(literal 1/2 binary64)) re (+.f64 re #s(literal 1 binary64)))
(fma.f64 #s(literal 1 binary64) re (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)))
(fma.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)) re)
(fma.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)) (.f64 #s(literal 1/2 binary64) (.f64 re re)))
(fma.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (.f64 re re)) (+.f64 re #s(literal 1 binary64)))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)) #s(literal 1 binary64) re)
(fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))
(fma.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)) (.f64 #s(literal 1/2 binary64) (*.f64 re re)))
(fma.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re re) re))) (.f64 #s(literal 1/2 binary64) (.f64 re re)))
(fma.f64 (*.f64 re re) #s(literal 1/2 binary64) (+.f64 re #s(literal 1 binary64)))
(fma.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal 1 binary64)) (.f64 #s(literal -1/2 binary64) (.f64 re re)))) re)
(fma.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) (.f64 #s(literal -1/2 binary64) (.f64 re re))))) re)
(fma.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (neg.f64 (/.f64 (.f64 re re) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re))))
(fma.f64 (fma.f64 re re #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))) (.f64 #s(literal 1/2 binary64) (.f64 re re)))
(fma.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) re)
(fma.f64 (neg.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))) (.f64 #s(literal 1/2 binary64) (*.f64 re re)))
(fma.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (+.f64 re #s(literal -1 binary64)))) (.f64 #s(literal 1/2 binary64) (.f64 re re)))
(fma.f64 (neg.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (+.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal 1 binary64)) (.f64 #s(literal -1/2 binary64) (.f64 re re))))) re)
(fma.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64)))) re)
(fma.f64 (-.f64 #s(literal 1 binary64) (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (.f64 re re)))) re)
(fma.f64 (-.f64 #s(literal 1 binary64) (.f64 re re)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)) (.f64 #s(literal 1/2 binary64) (*.f64 re re)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re re (-.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))))) (fma.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 re (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) (-.f64 (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (+.f64 re #s(literal 1 binary64))))) (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) (.f64 (+.f64 re #s(literal 1 binary64)) (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 (+.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (+.f64 re #s(literal 1 binary64))) (-.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (*.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))))))
(/.f64 (fma.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 re (.f64 re re))) (fma.f64 re (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)))))
(/.f64 (fma.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 re (.f64 re re))) (fma.f64 re re (-.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))))))
(/.f64 (.f64 (+.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re))
(/.f64 (neg.f64 (fma.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 re (.f64 re re)))) (neg.f64 (fma.f64 re (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))))))
(/.f64 (neg.f64 (fma.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 re (.f64 re re)))) (neg.f64 (fma.f64 re re (-.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)))))))
(/.f64 (neg.f64 (.f64 (+.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re))) (neg.f64 (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)))
(/.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) (.f64 (+.f64 re #s(literal 1 binary64)) (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))))) (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) (-.f64 (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (+.f64 re #s(literal 1 binary64))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))))))
(/.f64 (.f64 (+.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)))) (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))))
(/.f64 (-.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64)))) (-.f64 (.f64 #s(literal 1/2 binary64) (*.f64 re re)) (+.f64 re #s(literal 1 binary64))))
(/.f64 (-.f64 (.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (.f64 (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re) (.f64 re re))) (.f64 (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re) (-.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)) re)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 re (.f64 re re))))) (neg.f64 (neg.f64 (fma.f64 re (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (+.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)))) (neg.f64 (neg.f64 (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re))))
(/.f64 (neg.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) (.f64 (+.f64 re #s(literal 1 binary64)) (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64)))))) (neg.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) (-.f64 (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (+.f64 re #s(literal 1 binary64)))))))
(/.f64 (neg.f64 (.f64 (+.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))))) (neg.f64 (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)))))
(/.f64 (neg.f64 (-.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))))) (neg.f64 (-.f64 (.f64 #s(literal 1/2 binary64) (*.f64 re re)) (+.f64 re #s(literal 1 binary64)))))
(/.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (-.f64 (.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) (.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))))
(/.f64 (fma.f64 (+.f64 re #s(literal 1 binary64)) (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))) (.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)))) (fma.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64)) (-.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (.f64 (+.f64 re #s(literal 1 binary64)) (.f64 #s(literal 1/2 binary64) (.f64 re re))))))
(/.f64 (+.f64 (pow.f64 (+.f64 re (.f64 #s(literal 1/2 binary64) (.f64 re re))) #s(literal 3 binary64)) #s(literal 1 binary64)) (fma.f64 (+.f64 re (.f64 #s(literal 1/2 binary64) (.f64 re re))) (+.f64 re (.f64 #s(literal 1/2 binary64) (.f64 re re))) (-.f64 #s(literal 1 binary64) (.f64 (+.f64 re (.f64 #s(literal 1/2 binary64) (*.f64 re re))) #s(literal 1 binary64)))))
(/.f64 (+.f64 (pow.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) #s(literal 3 binary64)) #s(literal 1 binary64)) (fma.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re (*.f64 re #s(literal 1/2 binary64)) re) #s(literal 1 binary64)))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) #s(literal 3 binary64)) (pow.f64 (/.f64 (.f64 re re) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (/.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (fma.f64 (/.f64 (.f64 re re) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (/.f64 (.f64 re re) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (.f64 (/.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (/.f64 (.f64 re re) (-.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)) re))))))
(/.f64 (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re))) (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)))
(/.f64 (-.f64 (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))) (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)))) (-.f64 (+.f64 re #s(literal 1 binary64)) (.f64 #s(literal 1/2 binary64) (*.f64 re re))))
(/.f64 (-.f64 (.f64 (+.f64 re (.f64 #s(literal 1/2 binary64) (.f64 re re))) (+.f64 re (.f64 #s(literal 1/2 binary64) (.f64 re re)))) #s(literal 1 binary64)) (-.f64 (+.f64 re (.f64 #s(literal 1/2 binary64) (*.f64 re re))) #s(literal 1 binary64)))
(/.f64 (-.f64 (.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re)) #s(literal 1 binary64)) (-.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) re) #s(literal 1 binary64)))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (/.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re))) (.f64 (/.f64 (.f64 re re) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (/.f64 (.f64 re re) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)))) (+.f64 (/.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (/.f64 (.f64 re re) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)))) #s(literal -1 binary64))
(.f64 #s(literal 1 binary64) (+.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))))
(.f64 (fma.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 re (.f64 re re))) (/.f64 #s(literal 1 binary64) (fma.f64 re (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))))))
(.f64 (fma.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 re (.f64 re re))) (/.f64 #s(literal 1 binary64) (fma.f64 re re (-.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)))))))
(.f64 (.f64 (+.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)) re)))
(.f64 (neg.f64 (fma.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 re (.f64 re re)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)))))))
(.f64 (neg.f64 (.f64 (+.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) re))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)) re))))
(.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) (.f64 (+.f64 re #s(literal 1 binary64)) (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) (-.f64 (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) (*.f64 re re)) (+.f64 re #s(literal 1 binary64)))))))
(.f64 (.f64 (+.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64))) (-.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)))))
(.f64 (-.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (+.f64 re #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (+.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)))) (sin.f64 im))
(.f64 (sin.f64 im) #s(approx (exp re) (+.f64 re (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)))))
#s(approx (exp re) (+.f64 re (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))))
(+.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (.f64 re re)))
(+.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) #s(literal 1 binary64))
(+.f64 (/.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64)))))
(-.f64 (/.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))))
(-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (.f64 re re)))) (/.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (-.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (.f64 re re)))))
(fma.f64 re (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))
(fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))
(fma.f64 (*.f64 re #s(literal 1/2 binary64)) re #s(literal 1 binary64))
(fma.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (.f64 re re)) #s(literal 1 binary64))
(fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) #s(literal 1 binary64) #s(literal 1 binary64))
(fma.f64 (*.f64 re re) #s(literal 1/2 binary64) #s(literal 1 binary64))
(fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) (.f64 #s(literal -1/2 binary64) (.f64 re re)))) (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (.f64 re re))) (-.f64 #s(literal 1 binary64) (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))))))
(/.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (+.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal 1 binary64)) (.f64 #s(literal -1/2 binary64) (.f64 re re))))
(/.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (+.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) (.f64 #s(literal -1/2 binary64) (.f64 re re)))))
(/.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal -1 binary64)) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64)))
(/.f64 (neg.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) #s(literal 1 binary64))) (neg.f64 (+.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal 1 binary64)) (.f64 #s(literal -1/2 binary64) (.f64 re re)))))
(/.f64 (neg.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) #s(literal 1 binary64))) (neg.f64 (+.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) (.f64 #s(literal -1/2 binary64) (.f64 re re))))))
(/.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal -1 binary64))) (neg.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64)))))
(/.f64 (-.f64 #s(literal 1 binary64) (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)))) (-.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (.f64 re re))))
(/.f64 (-.f64 (.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64)) #s(literal 1 binary64))) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64)) (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal -1 binary64))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) #s(literal 1 binary64)))) (neg.f64 (neg.f64 (+.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal 1 binary64)) (.f64 #s(literal -1/2 binary64) (.f64 re re))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal -1 binary64)))) (neg.f64 (neg.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))))) (neg.f64 (-.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (.f64 re re)))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) (/.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) (.f64 (/.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal -1 binary64)))))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) (/.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64)))) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))))) (+.f64 (/.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64))) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal -1 binary64)))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal 1 binary64))) #s(literal -1 binary64))
(.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)))
(.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re re) #s(literal 1 binary64)) #s(literal 1 binary64))
(.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal 1 binary64)) (.f64 #s(literal -1/2 binary64) (*.f64 re re)))))
(.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) (.f64 #s(literal -1/2 binary64) (*.f64 re re))))))
(.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal -1 binary64))))
(.f64 (neg.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (.f64 re re)) #s(literal 1/8 binary64)) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (+.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal 1 binary64)) (.f64 #s(literal -1/2 binary64) (*.f64 re re))))))
(.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 #s(literal 1/2 binary64) (*.f64 re re) #s(literal -1 binary64)))))
(.f64 (-.f64 #s(literal 1 binary64) (.f64 (.f64 re re) (.f64 (.f64 re re) #s(literal 1/4 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (*.f64 re re)))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
(*.f64 im #s(approx (exp re) #s(literal 1 binary64)))
(*.f64 #s(approx (exp re) #s(literal 1 binary64)) im)
#s(approx (exp re) #s(literal 1 binary64))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im)))
#s(approx (sin im) (fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im))
(+.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im))))
(+.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im))) im)
(+.f64 (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) (neg.f64 (/.f64 (.f64 im im) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im))) im))))
(-.f64 (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im))) im)))
(-.f64 (/.f64 (.f64 im im) (+.f64 im (.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im im))))) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (+.f64 im (.f64 #s(literal 1/6 binary64) (.f64 im (*.f64 im im))))))
(fma.f64 im (.f64 im (.f64 im #s(literal -1/6 binary64))) im)
(fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im)
(fma.f64 (.f64 im im) (.f64 im #s(literal -1/6 binary64)) im)
(fma.f64 (.f64 im (.f64 im #s(literal -1/6 binary64))) im im)
(fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)
(fma.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) (neg.f64 (/.f64 (.f64 im im) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im))) im))))
(fma.f64 (.f64 im #s(literal -1/6 binary64)) (.f64 im im) im)
(fma.f64 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 im #s(literal 1/2 binary64)) (.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im im (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)))))) (fma.f64 im (.f64 im im) (.f64 #s(literal -1/216 binary64) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im im) (.f64 (.f64 im im) (.f64 im im))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 im (.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im im)))) (-.f64 (.f64 im im) (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))))))
(/.f64 (fma.f64 im (.f64 im im) (.f64 #s(literal -1/216 binary64) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im im) (.f64 (.f64 im im) (.f64 im im)))))) (fma.f64 im (+.f64 im (.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (*.f64 im im) #s(literal 1/36 binary64)))))
(/.f64 (fma.f64 im (.f64 im im) (.f64 #s(literal -1/216 binary64) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im im) (.f64 (.f64 im im) (.f64 im im)))))) (fma.f64 im im (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)))))))
(/.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im)) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im))
(/.f64 (neg.f64 (fma.f64 im (.f64 im im) (.f64 #s(literal -1/216 binary64) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im im) (.f64 (.f64 im im) (.f64 im im))))))) (neg.f64 (fma.f64 im (+.f64 im (.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (*.f64 im im) #s(literal 1/36 binary64))))))
(/.f64 (neg.f64 (fma.f64 im (.f64 im im) (.f64 #s(literal -1/216 binary64) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im im) (.f64 (.f64 im im) (.f64 im im))))))) (neg.f64 (fma.f64 im im (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))))))))
(/.f64 (neg.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im))) (neg.f64 (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im))))
(/.f64 (-.f64 (.f64 im im) (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) (+.f64 im (.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im im)))))
(/.f64 (-.f64 (.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) (.f64 (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im) (.f64 im im))) (.f64 (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 im (.f64 im im) (.f64 #s(literal -1/216 binary64) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im im) (.f64 (.f64 im im) (.f64 im im)))))))) (neg.f64 (neg.f64 (fma.f64 im (+.f64 im (.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (*.f64 im im) #s(literal 1/36 binary64)))))))
(/.f64 (neg.f64 (neg.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im)))) (neg.f64 (neg.f64 (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im))))
(/.f64 (neg.f64 (-.f64 (.f64 im im) (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))))) (neg.f64 (+.f64 im (.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im im))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (.f64 im im) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) (fma.f64 (/.f64 (.f64 im im) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) (.f64 (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im))) im))))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im))) (.f64 (/.f64 (.f64 im im) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)))) (+.f64 (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im))) im))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im)) #s(literal -1 binary64))
(.f64 #s(literal 1 binary64) (fma.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im)) im))
(.f64 (fma.f64 im (.f64 im im) (.f64 #s(literal -1/216 binary64) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im im) (.f64 (.f64 im im) (.f64 im im)))))) (/.f64 #s(literal 1 binary64) (fma.f64 im (+.f64 im (.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))))))
(.f64 (fma.f64 im (.f64 im im) (.f64 #s(literal -1/216 binary64) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im im) (.f64 (.f64 im im) (.f64 im im)))))) (/.f64 #s(literal 1 binary64) (fma.f64 im im (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im))))))))
(.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im))) im)))
(.f64 (neg.f64 (fma.f64 im (.f64 im im) (.f64 #s(literal -1/216 binary64) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im im) (.f64 (.f64 im im) (.f64 im im))))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 im (+.f64 im (.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64)))))))
(.f64 (neg.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im))) im))))
(.f64 (-.f64 (.f64 im im) (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 im (.f64 #s(literal 1/6 binary64) (.f64 im (*.f64 im im))))))
(.f64 (fma.f64 im (.f64 im #s(literal -1/6 binary64)) #s(literal 1 binary64)) im)
(.f64 im (.f64 im #s(literal -1/6 binary64)))
(.f64 #s(literal -1/6 binary64) (.f64 im im))
(.f64 (.f64 im im) #s(literal -1/6 binary64))
(.f64 (.f64 im #s(literal -1/6 binary64)) im)
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))
(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) im)
#s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re))
(+.f64 (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) #s(literal 1 binary64))
(+.f64 (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)))) (+.f64 re #s(literal 1 binary64)))
(+.f64 (/.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re)
(-.f64 (/.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))))
(-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re))) (/.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (-.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (+.f64 re #s(literal 1 binary64)))
(fma.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) #s(literal 1 binary64))
(fma.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (*.f64 re re) (+.f64 re #s(literal 1 binary64)))
(fma.f64 (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) re #s(literal 1 binary64))
(fma.f64 (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) #s(literal 1 binary64) #s(literal 1 binary64))
(fma.f64 (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re (+.f64 re #s(literal 1 binary64)))
(fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (+.f64 re #s(literal 1 binary64)))
(fma.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(fma.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)))))) (.f64 re (.f64 re re))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) (-.f64 (.f64 re re) (.f64 (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)))) re)))) #s(literal 1 binary64))
(fma.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (neg.f64 re))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (neg.f64 re))) #s(literal 1 binary64))
(fma.f64 (.f64 re (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal 1 binary64)) (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) #s(literal 1 binary64))
(fma.f64 (.f64 re (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64))
(fma.f64 (.f64 (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) #s(literal 1 binary64)) re) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal 1 binary64)) (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) #s(literal 1 binary64))
(fma.f64 (.f64 (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal -1 binary64)) re) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (-.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re))) (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)))))
(/.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) #s(literal 1 binary64)) (-.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) #s(literal 1 binary64)) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)))
(/.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) #s(literal 1 binary64)) (+.f64 #s(literal 1 binary64) (-.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re))))
(/.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) #s(literal -1 binary64)) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))
(/.f64 (neg.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) #s(literal 1 binary64))) (neg.f64 (-.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) #s(literal 1 binary64)) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re))))
(/.f64 (neg.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) #s(literal 1 binary64))) (neg.f64 (+.f64 #s(literal 1 binary64) (-.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)))))
(/.f64 (neg.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) #s(literal -1 binary64))) (neg.f64 (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(/.f64 (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re))) (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)))
(/.f64 (-.f64 (.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (.f64 (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64))) (.f64 (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) #s(literal 1 binary64)))) (neg.f64 (neg.f64 (-.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) #s(literal 1 binary64)) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) #s(literal -1 binary64)))) (neg.f64 (neg.f64 (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)))) (neg.f64 (-.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re))))
(/.f64 (fma.f64 (.f64 re (.f64 re re)) (.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)))))) (.f64 (+.f64 re #s(literal 1 binary64)) (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))))) (fma.f64 (.f64 re re) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) (-.f64 (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))) (.f64 (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)))) (+.f64 re #s(literal 1 binary64))))))
(/.f64 (+.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) #s(literal 3 binary64)) (.f64 re (.f64 re re))) (fma.f64 (+.f64 #s(literal 1 binary64) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) (+.f64 #s(literal 1 binary64) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) (-.f64 (.f64 re re) (.f64 (+.f64 #s(literal 1 binary64) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (.f64 (/.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))))))
(/.f64 (-.f64 (.f64 (.f64 re re) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)))))) (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64)))) (-.f64 (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)))) (+.f64 re #s(literal 1 binary64))))
(/.f64 (-.f64 (.f64 (+.f64 #s(literal 1 binary64) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) (+.f64 #s(literal 1 binary64) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)))))) (.f64 re re)) (-.f64 (+.f64 #s(literal 1 binary64) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))))) (+.f64 (/.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) #s(literal 1 binary64)) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re))))
(.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (-.f64 (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)))))
(.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))))
(.f64 (neg.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) #s(literal 1 binary64)) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re)))))
(.f64 (neg.f64 (fma.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(.f64 (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re) (fma.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) re))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (.f64 im im) (.f64 im (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)))
(.f64 #s(approx (sin im) (fma.f64 (.f64 im im) (.f64 im (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) #s(approx (exp re) (+.f64 re #s(literal 1 binary64))))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(+.f64 re #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) re)
(+.f64 (/.f64 (*.f64 re re) (+.f64 re #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))))
(-.f64 (/.f64 (*.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))))
(-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)) (/.f64 (*.f64 re re) (-.f64 #s(literal 1 binary64) re)))
(fma.f64 re #s(literal 1 binary64) #s(literal 1 binary64))
(fma.f64 #s(literal 1 binary64) re #s(literal 1 binary64))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re re) re)) (fma.f64 re (.f64 re re) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 1 binary64) (*.f64 re re))))
(/.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64)) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))
(/.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re re) re)))
(/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))
(/.f64 (neg.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64))) (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(/.f64 (neg.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64))) (neg.f64 (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re re) re))))
(/.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64))) (neg.f64 (+.f64 re #s(literal -1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
(/.f64 (-.f64 #s(literal 1 binary64) (*.f64 re re)) (-.f64 #s(literal 1 binary64) re))
(/.f64 (-.f64 (.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (.f64 (+.f64 re #s(literal -1 binary64)) #s(literal 1 binary64))) (.f64 (+.f64 re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64)))) (neg.f64 (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64)))) (neg.f64 (neg.f64 (+.f64 re #s(literal -1 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (*.f64 re re))) (neg.f64 (-.f64 #s(literal 1 binary64) re)))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))) (.f64 (/.f64 (*.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64)))) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))))) (+.f64 (/.f64 (*.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64)))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))
(.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (-.f64 (*.f64 re re) re))))
(*.f64 (fma.f64 re re #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal -1 binary64))))
(.f64 (neg.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))))
(*.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (+.f64 re #s(literal -1 binary64)))))
(.f64 (-.f64 #s(literal 1 binary64) (.f64 re re)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)))
#s(approx (sin im) (fma.f64 (.f64 im im) (.f64 im (fma.f64 im (*.f64 im #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im))
(sin.f64 im)
(+.f64 #s(literal 1/2 binary64) (*.f64 re #s(literal 1/6 binary64)))
(+.f64 (*.f64 re #s(literal 1/6 binary64)) #s(literal 1/2 binary64))
(+.f64 (/.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) (neg.f64 (/.f64 #s(literal 1/4 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64)))))
(-.f64 (/.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) (/.f64 #s(literal 1/4 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))))
(-.f64 (/.f64 #s(literal 1/4 binary64) (-.f64 #s(literal 1/2 binary64) (.f64 re #s(literal 1/6 binary64)))) (/.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (-.f64 #s(literal 1/2 binary64) (.f64 re #s(literal 1/6 binary64)))))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(fma.f64 #s(literal 1/6 binary64) re #s(literal 1/2 binary64))
(fma.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) (neg.f64 (/.f64 #s(literal 1/4 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1/4 binary64) (-.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (.f64 re #s(literal 1/12 binary64)))) (fma.f64 (.f64 re (*.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 1/2 binary64) (.f64 re #s(literal 1/6 binary64))) (-.f64 #s(literal 1/4 binary64) (.f64 #s(literal 1/36 binary64) (*.f64 re re)))))
(/.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)) (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (.f64 re #s(literal 1/12 binary64))))
(/.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)) (+.f64 #s(literal 1/4 binary64) (-.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (*.f64 re #s(literal 1/12 binary64)))))
(/.f64 (fma.f64 #s(literal 1/36 binary64) (*.f64 re re) #s(literal -1/4 binary64)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64)))
(/.f64 (neg.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64))) (neg.f64 (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (.f64 re #s(literal 1/12 binary64)))))
(/.f64 (neg.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64))) (neg.f64 (+.f64 #s(literal 1/4 binary64) (-.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (*.f64 re #s(literal 1/12 binary64))))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/36 binary64) (*.f64 re re) #s(literal -1/4 binary64))) (neg.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)))))
(/.f64 (-.f64 #s(literal 1/4 binary64) (.f64 #s(literal 1/36 binary64) (.f64 re re))) (-.f64 #s(literal 1/2 binary64) (*.f64 re #s(literal 1/6 binary64))))
(/.f64 (-.f64 (.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64)) #s(literal 1/4 binary64))) (*.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)))) (neg.f64 (neg.f64 (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (.f64 re #s(literal 1/12 binary64))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 #s(literal 1/36 binary64) (*.f64 re re) #s(literal -1/4 binary64)))) (neg.f64 (neg.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 1/4 binary64) (.f64 #s(literal 1/36 binary64) (.f64 re re)))) (neg.f64 (-.f64 #s(literal 1/2 binary64) (*.f64 re #s(literal 1/6 binary64)))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 1/4 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) (/.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) (/.f64 #s(literal 1/4 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) (.f64 (/.f64 (.f64 #s(literal 1/36 binary64) (*.f64 re re)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) (/.f64 #s(literal 1/4 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64)))))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) (/.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64)))) (.f64 (/.f64 #s(literal 1/4 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) (/.f64 #s(literal 1/4 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))))) (+.f64 (/.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) (/.f64 #s(literal 1/4 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64)))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)))
(*.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (*.f64 re #s(literal 1/12 binary64)))))
(.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1/4 binary64) (-.f64 (.f64 #s(literal 1/36 binary64) (.f64 re re)) (.f64 re #s(literal 1/12 binary64))))))
(.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal -1/4 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))))
(.f64 (neg.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (*.f64 re #s(literal 1/12 binary64))))))
(.f64 (neg.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal -1/4 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64)))))
(.f64 (-.f64 #s(literal 1/4 binary64) (.f64 #s(literal 1/36 binary64) (.f64 re re))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1/2 binary64) (.f64 re #s(literal 1/6 binary64)))))
(+.f64 #s(literal -1/6 binary64) (.f64 (.f64 im im) #s(literal 1/120 binary64)))
(+.f64 (.f64 (.f64 im im) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))
(+.f64 (/.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (neg.f64 (/.f64 #s(literal 1/36 binary64) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64)))))
(-.f64 (/.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (/.f64 #s(literal 1/36 binary64) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))))
(-.f64 (/.f64 #s(literal 1/36 binary64) (+.f64 #s(literal -1/6 binary64) (.f64 #s(literal -1/120 binary64) (.f64 im im)))) (/.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (+.f64 #s(literal -1/6 binary64) (.f64 #s(literal -1/120 binary64) (.f64 im im)))))
(fma.f64 im (*.f64 im #s(literal 1/120 binary64)) #s(literal -1/6 binary64))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(fma.f64 #s(literal 1/120 binary64) (*.f64 im im) #s(literal -1/6 binary64))
(fma.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (neg.f64 (/.f64 #s(literal 1/36 binary64) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64)))))
(fma.f64 (*.f64 im #s(literal 1/120 binary64)) im #s(literal -1/6 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1/36 binary64) (-.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (.f64 (.f64 im im) #s(literal -1/720 binary64)))) (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (*.f64 im im)) #s(literal 1/1728000 binary64)) #s(literal -1/216 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal -1/6 binary64) (.f64 #s(literal -1/120 binary64) (.f64 im im))) (-.f64 #s(literal 1/36 binary64) (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))))))
(/.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal 1/1728000 binary64)) #s(literal -1/216 binary64)) (-.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64)) #s(literal 1/36 binary64)) (.f64 (.f64 im im) #s(literal -1/720 binary64))))
(/.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal 1/1728000 binary64)) #s(literal -1/216 binary64)) (+.f64 #s(literal 1/36 binary64) (-.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (.f64 (*.f64 im im) #s(literal -1/720 binary64)))))
(/.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64)) #s(literal -1/36 binary64)) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64)))
(/.f64 (neg.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal 1/1728000 binary64)) #s(literal -1/216 binary64))) (neg.f64 (-.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64)) #s(literal 1/36 binary64)) (.f64 (.f64 im im) #s(literal -1/720 binary64)))))
(/.f64 (neg.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal 1/1728000 binary64)) #s(literal -1/216 binary64))) (neg.f64 (+.f64 #s(literal 1/36 binary64) (-.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (.f64 (*.f64 im im) #s(literal -1/720 binary64))))))
(/.f64 (neg.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64)) #s(literal -1/36 binary64))) (neg.f64 (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))))
(/.f64 (-.f64 #s(literal 1/36 binary64) (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64)))) (+.f64 #s(literal -1/6 binary64) (.f64 #s(literal -1/120 binary64) (.f64 im im))))
(/.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (.f64 (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64)) #s(literal 1/36 binary64))) (.f64 (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64)) (fma.f64 im (*.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal 1/1728000 binary64)) #s(literal -1/216 binary64)))) (neg.f64 (neg.f64 (-.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64)) #s(literal 1/36 binary64)) (.f64 (.f64 im im) #s(literal -1/720 binary64))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64)) #s(literal -1/36 binary64)))) (neg.f64 (neg.f64 (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 1/36 binary64) (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))))) (neg.f64 (+.f64 #s(literal -1/6 binary64) (.f64 #s(literal -1/120 binary64) (.f64 im im)))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 1/36 binary64) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (/.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (fma.f64 (/.f64 #s(literal 1/36 binary64) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (/.f64 #s(literal 1/36 binary64) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (.f64 (/.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (/.f64 #s(literal 1/36 binary64) (fma.f64 im (*.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64)))))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (/.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64)))) (.f64 (/.f64 #s(literal 1/36 binary64) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (/.f64 #s(literal 1/36 binary64) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))))) (+.f64 (/.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (/.f64 #s(literal 1/36 binary64) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64)))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) #s(literal -1 binary64))
(.f64 #s(literal 1 binary64) (fma.f64 im (.f64 im #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))
(.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal 1/1728000 binary64)) #s(literal -1/216 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64)) #s(literal 1/36 binary64)) (.f64 (*.f64 im im) #s(literal -1/720 binary64)))))
(.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal 1/1728000 binary64)) #s(literal -1/216 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1/36 binary64) (-.f64 (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64))) (.f64 (.f64 im im) #s(literal -1/720 binary64))))))
(.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64)) #s(literal -1/36 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64))))
(.f64 (neg.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal 1/1728000 binary64)) #s(literal -1/216 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64)) #s(literal 1/36 binary64)) (.f64 (*.f64 im im) #s(literal -1/720 binary64))))))
(.f64 (neg.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64)) #s(literal -1/36 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 im (*.f64 im #s(literal 1/120 binary64)) #s(literal 1/6 binary64)))))
(.f64 (-.f64 #s(literal 1/36 binary64) (.f64 (.f64 im im) (.f64 (.f64 im im) #s(literal 1/14400 binary64)))) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal -1/6 binary64) (.f64 #s(literal -1/120 binary64) (*.f64 im im)))))
(exp.f64 (*.f64 (log.f64 im) #s(literal 3 binary64)))
(pow.f64 im #s(literal 3 binary64))
(pow.f64 (*.f64 im im) #s(literal 3/2 binary64))
(pow.f64 (pow.f64 im #s(literal 3/2 binary64)) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 im)) #s(literal 3 binary64))
(.f64 im (.f64 im im))
(.f64 (.f64 im im) im)
(*.f64 (pow.f64 im #s(literal 3/2 binary64)) (pow.f64 im #s(literal 3/2 binary64)))

eval196.0ms (1.2%)

Memory: 16.9MiB live, 90.6MiB allocated
Compiler: Compiled 14 824 to 1 318 computations (91.1% saved)

prune200.0ms (1.2%)

Memory

12.4MiB live, 96.1MiB allocated

Pruning

29 alts after pruning (23 fresh and 6 done)

	Pruned	Kept	Total
New	677	18	695
Fresh	4	5	9
Picked	3	2	5
Done	0	4	4
Total	684	29	713

Accuracy

100.0%

Counts

713 → 29

Alt Table

Click to see full alt table

Status	Accuracy	Program
	39.6%	(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
✓	69.1%	(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))
	39.3%	(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
▶	69.0%	(*.f64 #s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (sin.f64 im))
✓	69.1%	(.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im))
✓	54.7%	(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
	30.3%	(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im #s(literal 1/120 binary64)) im #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
	29.8%	(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) (.f64 (.f64 im im) #s(literal 1/120 binary64))) (.f64 im (.f64 im im)) im)))
▶	33.7%	(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
✓	64.8%	#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
	29.1%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 (.f64 (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal -1 binary64)) re) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64)))))
	27.2%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)) (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (*.f64 re #s(literal 1/12 binary64)))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
	38.7%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal -1/4 binary64)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
▶	38.3%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
	38.7%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))))
	29.0%	#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
	15.9%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)))))
	15.9%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
	15.5%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
✓	26.5%	#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
✓	53.9%	#s(approx (* (exp re) (sin im)) (sin.f64 im))
	37.3%	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
	34.0%	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
▶	29.0%	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
	29.6%	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)))
▶	33.8%	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
	33.4%	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
	23.6%	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (/.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im)) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im))))
	19.3%	#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))

Compiler

Compiled 915 to 474 computations (48.2% saved)

simplify533.0ms (3.3%)

Memory

-11.4MiB live, 387.6MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 19 expressions of interest:

New	Metric	Score
cost-diff	0	(fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))
cost-diff	0	(fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)
cost-diff	0	#s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
cost-diff	0	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
cost-diff	0	#s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
cost-diff	0	(+.f64 re #s(literal 1 binary64))
cost-diff	0	#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
cost-diff	0	(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
cost-diff	0	(fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
cost-diff	0	#s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
cost-diff	0	(.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))
cost-diff	0	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
cost-diff	0	(fma.f64 re im im)
cost-diff	0	#s(approx (* im (exp re)) (fma.f64 re im im))
cost-diff	0	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
cost-diff	0	(fma.f64 re re #s(literal -1 binary64))
cost-diff	0	#s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))
cost-diff	0	(*.f64 #s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (sin.f64 im))
cost-diff	1088	(/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))

Rules

12 346×	`lower-fma.f32`
12 330×	`lower-fma.f64`
3 150×	`lower-*.f32`
3 138×	`lower-*.f64`
2 120×	`lower-+.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	47	361
0	74	355
1	129	355
2	204	330
3	390	330
4	753	330
5	1818	330
6	5229	330
0	8242	320

Stop Event

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

Calls

Call 1

Inputs
(*.f64 #s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (sin.f64 im))
#s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))
(/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))
(fma.f64 re re #s(literal -1 binary64))
re
#s(literal -1 binary64)
(+.f64 re #s(literal -1 binary64))
(sin.f64 im)
im
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* im (exp re)) (fma.f64 re im im))
(fma.f64 re im im)
re
im
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))
im
#s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
re
(fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64))
#s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64))
#s(literal 1/2 binary64)
#s(literal 1 binary64)
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(+.f64 re #s(literal 1 binary64))
re
#s(literal 1 binary64)
#s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)
#s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64))
#s(literal -1/6 binary64)
(.f64 im (.f64 im im))
im
(*.f64 im im)
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)
(fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))
im
(.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))
(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))
(*.f64 im im)
#s(literal -1/5040 binary64)
#s(literal 1/120 binary64)
#s(literal -1/6 binary64)
(.f64 im (.f64 im im))

Outputs
(*.f64 #s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (sin.f64 im))
(*.f64 (sin.f64 im) #s(approx (exp re) (+.f64 re #s(literal 1 binary64))))
#s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))
(+.f64 re #s(literal 1 binary64))
(fma.f64 re re #s(literal -1 binary64))
re
#s(literal -1 binary64)
(+.f64 re #s(literal -1 binary64))
(sin.f64 im)
im
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* im (exp re)) (fma.f64 re im im))
(fma.f64 re im im)
re
im
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))
im
#s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
re
(fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64))
#s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64))
#s(literal 1/2 binary64)
#s(literal 1 binary64)
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(+.f64 re #s(literal 1 binary64))
re
#s(literal 1 binary64)
#s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)
#s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64))
#s(literal -1/6 binary64)
(.f64 im (.f64 im im))
im
(*.f64 im im)
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) im)))
#s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
#s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) im))
(fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)
(fma.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) im)
(fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))
(fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))
im
(.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))
(.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))
(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))
(fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))
(*.f64 im im)
#s(literal -1/5040 binary64)
#s(literal 1/120 binary64)
#s(literal -1/6 binary64)
(.f64 im (.f64 im im))

localize278.0ms (1.7%)

Memory

-5.0MiB live, 235.5MiB allocated

Localize:

Found 19 expressions of interest:

New	Metric	Score
accuracy	0.0859375	(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))
accuracy	0.08984375	(.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))
accuracy	29.518157205544824	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
accuracy	31.360534236121364	#s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
accuracy	0.06640625	(.f64 im (.f64 im im))
accuracy	28.936626058771207	#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
accuracy	31.374354038378968	#s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
accuracy	32.04483852380143	#s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64))
accuracy	0.06640625	(fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
accuracy	18.133113674950557	#s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
accuracy	22.529110259401293	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
accuracy	29.593235647402697	#s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64))
accuracy	0	(fma.f64 re im im)
accuracy	22.529110259401293	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
accuracy	24.071557774950676	#s(approx (* im (exp re)) (fma.f64 re im im))
accuracy	0	(sin.f64 im)
accuracy	0.01953125	(*.f64 #s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (sin.f64 im))
accuracy	15.384162530454692	(/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))
accuracy	28.936626058771207	#s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))

Samples

215.0ms

256×

valid

Compiler

Compiled 204 to 41 computations (79.9% saved)

Precisions

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

ival-mult: 86.0ms (55.8% of total)

const: 45.0ms (29.2% of total)

ival-add: 13.0ms (8.4% of total)

ival-sin: 6.0ms (3.9% of total)

ival-div: 2.0ms (1.3% of total)

ival-exp: 2.0ms (1.3% of total)

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

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

exact: 0.0ms (0% of total)

series10.0ms (0.1%)

Memory

14.4MiB live, 14.4MiB allocated

Counts

25 → 396

Calls

Call 1

Inputs
#<alt (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))>
#<alt (*.f64 #s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (sin.f64 im))>
#<alt #s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))>
#<alt (fma.f64 re re #s(literal -1 binary64))>
#<alt #s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))>
#<alt #s(approx (* im (exp re)) (fma.f64 re im im))>
#<alt (fma.f64 re im im)>
#<alt #s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))>
#<alt (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))>
#<alt #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))>
#<alt (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))>
#<alt (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))>
#<alt #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))>
#<alt (+.f64 re #s(literal 1 binary64))>
#<alt #s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))>
#<alt #s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))>
#<alt #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))>
#<alt (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)>
#<alt (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))>
#<alt (sin.f64 im)>
#<alt #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64))>
#<alt #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64))>
#<alt (.f64 im (.f64 im im))>
#<alt (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))>
#<alt (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))>

Outputs
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 re)>
#<alt (+ 1 re)>
#<alt re>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt re>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt -1>
#<alt (- (pow re 2) 1)>
#<alt (- (pow re 2) 1)>
#<alt (- (pow re 2) 1)>
#<alt (pow re 2)>
#<alt (* (pow re 2) (- 1 (/ 1 (pow re 2))))>
#<alt (* (pow re 2) (- 1 (/ 1 (pow re 2))))>
#<alt (* (pow re 2) (- 1 (/ 1 (pow re 2))))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (- 1 (/ 1 (pow re 2))))>
#<alt (* (pow re 2) (- 1 (/ 1 (pow re 2))))>
#<alt (* (pow re 2) (- 1 (/ 1 (pow re 2))))>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt im>
#<alt (+ im (* im re))>
#<alt (+ im (* re (+ im (* 1/2 (* im re)))))>
#<alt (+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt im>
#<alt (+ im (* im re))>
#<alt (+ im (* im re))>
#<alt (+ im (* im re))>
#<alt (* im re)>
#<alt (* re (+ im (/ im re)))>
#<alt (* re (+ im (/ im re)))>
#<alt (* re (+ im (/ im re)))>
#<alt (* im re)>
#<alt (* -1 (* re (+ (* -1 im) (* -1 (/ im re)))))>
#<alt (* -1 (* re (+ (* -1 im) (* -1 (/ im re)))))>
#<alt (* -1 (* re (+ (* -1 im) (* -1 (/ im re)))))>
#<alt (* im (+ 1 re))>
#<alt (* im (+ 1 re))>
#<alt (* im (+ 1 re))>
#<alt (* im (+ 1 re))>
#<alt (* im (+ 1 re))>
#<alt (* im (+ 1 re))>
#<alt (* im (+ 1 re))>
#<alt (* im (+ 1 re))>
#<alt (* -1 (* im (- (* -1 re) 1)))>
#<alt (* -1 (* im (- (* -1 re) 1)))>
#<alt (* -1 (* im (- (* -1 re) 1)))>
#<alt (* -1 (* im (- (* -1 re) 1)))>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt im>
#<alt (+ im (* im re))>
#<alt (+ im (* re (+ im (* 1/2 (* im re)))))>
#<alt (+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt (* im (exp re))>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))>
#<alt (* 1/6 (pow re 3))>
#<alt (* (pow re 3) (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* (pow re 3) (+ 1/6 (+ (* 1/2 (/ 1 re)) (/ 1 (pow re 2)))))>
#<alt (* (pow re 3) (+ 1/6 (+ (* 1/2 (/ 1 re)) (+ (/ 1 (pow re 2)) (/ 1 (pow re 3))))))>
#<alt (* 1/6 (pow re 3))>
#<alt (* (pow re 3) (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* -1 (* (pow re 3) (- (* -1 (/ (+ 1/2 (/ 1 re)) re)) 1/6)))>
#<alt (* -1 (* (pow re 3) (- (* -1 (/ (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))) re)) 1/6)))>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 (* re (+ 1 (* 1/2 re))))>
#<alt (+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt (exp re)>
#<alt 1>
#<alt (+ 1 re)>
#<alt (+ 1 re)>
#<alt (+ 1 re)>
#<alt re>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt re>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt (* re (+ 1 (/ 1 re)))>
#<alt im>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (+ (sin im) (* re (sin im)))>
#<alt (+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))>
#<alt (+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* im (exp re))>
#<alt (* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))>
#<alt (* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt (* (exp re) (sin im))>
#<alt im>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt im>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))>
#<alt (* -1/5040 (pow im 7))>
#<alt (* (pow im 7) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))>
#<alt (* (pow im 7) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))>
#<alt (* (pow im 7) (- (+ (* 1/120 (/ 1 (pow im 2))) (/ 1 (pow im 6))) (+ 1/5040 (/ 1/6 (pow im 4)))))>
#<alt (* -1/5040 (pow im 7))>
#<alt (* -1 (* (pow im 7) (- 1/5040 (* 1/120 (/ 1 (pow im 2))))))>
#<alt (* -1 (* (pow im 7) (- (+ 1/5040 (/ 1/6 (pow im 4))) (* 1/120 (/ 1 (pow im 2))))))>
#<alt (* -1 (* (pow im 7) (- (+ 1/5040 (/ 1/6 (pow im 4))) (+ (* 1/120 (/ 1 (pow im 2))) (/ 1 (pow im 6))))))>
#<alt -1/6>
#<alt (- (* 1/120 (pow im 2)) 1/6)>
#<alt (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6)>
#<alt (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6)>
#<alt (* -1/5040 (pow im 4))>
#<alt (* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))>
#<alt (* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))>
#<alt (* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))>
#<alt (* -1/5040 (pow im 4))>
#<alt (* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))>
#<alt (* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))>
#<alt (* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))>
#<alt im>
#<alt (* im (+ 1 (* -1/6 (pow im 2))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))>
#<alt (* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt (sin im)>
#<alt 1/2>
#<alt (+ 1/2 (* 1/6 re))>
#<alt (+ 1/2 (* 1/6 re))>
#<alt (+ 1/2 (* 1/6 re))>
#<alt (* 1/6 re)>
#<alt (* re (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* re (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* re (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* 1/6 re)>
#<alt (* re (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* re (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt (* re (+ 1/6 (* 1/2 (/ 1 re))))>
#<alt -1/6>
#<alt (- (* 1/120 (pow im 2)) 1/6)>
#<alt (- (* 1/120 (pow im 2)) 1/6)>
#<alt (- (* 1/120 (pow im 2)) 1/6)>
#<alt (* 1/120 (pow im 2))>
#<alt (* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))>
#<alt (* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))>
#<alt (* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))>
#<alt (* 1/120 (pow im 2))>
#<alt (* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))>
#<alt (* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))>
#<alt (* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (pow im 3)>
#<alt (* 1/120 im)>
#<alt (* im (+ 1/120 (* -1/5040 (pow im 2))))>
#<alt (* im (+ 1/120 (* -1/5040 (pow im 2))))>
#<alt (* im (+ 1/120 (* -1/5040 (pow im 2))))>
#<alt (* -1/5040 (pow im 3))>
#<alt (* (pow im 3) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))>
#<alt (* (pow im 3) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))>
#<alt (* (pow im 3) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))>
#<alt (* -1/5040 (pow im 3))>
#<alt (* -1 (* (pow im 3) (- 1/5040 (* 1/120 (/ 1 (pow im 2))))))>
#<alt (* -1 (* (pow im 3) (- 1/5040 (* 1/120 (/ 1 (pow im 2))))))>
#<alt (* -1 (* (pow im 3) (- 1/5040 (* 1/120 (/ 1 (pow im 2))))))>
#<alt 1/120>
#<alt (+ 1/120 (* -1/5040 (pow im 2)))>
#<alt (+ 1/120 (* -1/5040 (pow im 2)))>
#<alt (+ 1/120 (* -1/5040 (pow im 2)))>
#<alt (* -1/5040 (pow im 2))>
#<alt (* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))>
#<alt (* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))>
#<alt (* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))>
#<alt (* -1/5040 (pow im 2))>
#<alt (* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))>
#<alt (* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))>
#<alt (* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))>

Calls

99 calls:

Time	Variable		Point	Expression
0.0ms	im	@	inf	(+ (* (+ (* im (* im (+ (* (* im im) -1/5040) 1/120))) -1/6) (* im (* im im))) im)
0.0ms	im	@	-inf	(+ (* (+ (* im (* im (+ (* (* im im) -1/5040) 1/120))) -1/6) (* im (* im im))) im)
0.0ms	im	@	inf	(+ (* re im) im)
0.0ms	im	@	inf	(* im (+ (* (* im im) -1/5040) 1/120))
0.0ms	re	@	-inf	(/ (+ (* re re) -1) (+ re -1))

simplify7.6s (46.6%)

Memory

13.7MiB live, 569.2MiB allocated

Algorithm

1×	egg-herbie

Rules

13 054×	`lower-fma.f64`
13 054×	`lower-fma.f32`
4 898×	`lower-*.f64`
4 898×	`lower-*.f32`
3 362×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	177	2469
1	544	2390
2	1543	2354
3	4661	2318
0	8109	2129

Stop Event

1×	iter limit
1×	node limit

Counts

396 → 385

Calls

Call 1

Inputs
1
(+ 1 re)
(+ 1 re)
(+ 1 re)
re
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
re
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
-1
(- (pow re 2) 1)
(- (pow re 2) 1)
(- (pow re 2) 1)
(pow re 2)
(* (pow re 2) (- 1 (/ 1 (pow re 2))))
(* (pow re 2) (- 1 (/ 1 (pow re 2))))
(* (pow re 2) (- 1 (/ 1 (pow re 2))))
(pow re 2)
(* (pow re 2) (- 1 (/ 1 (pow re 2))))
(* (pow re 2) (- 1 (/ 1 (pow re 2))))
(* (pow re 2) (- 1 (/ 1 (pow re 2))))
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
im
(+ im (* im re))
(+ im (* re (+ im (* 1/2 (* im re)))))
(+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
im
(+ im (* im re))
(+ im (* im re))
(+ im (* im re))
(* im re)
(* re (+ im (/ im re)))
(* re (+ im (/ im re)))
(* re (+ im (/ im re)))
(* im re)
(* -1 (* re (+ (* -1 im) (* -1 (/ im re)))))
(* -1 (* re (+ (* -1 im) (* -1 (/ im re)))))
(* -1 (* re (+ (* -1 im) (* -1 (/ im re)))))
(* im (+ 1 re))
(* im (+ 1 re))
(* im (+ 1 re))
(* im (+ 1 re))
(* im (+ 1 re))
(* im (+ 1 re))
(* im (+ 1 re))
(* im (+ 1 re))
(* -1 (* im (- (* -1 re) 1)))
(* -1 (* im (- (* -1 re) 1)))
(* -1 (* im (- (* -1 re) 1)))
(* -1 (* im (- (* -1 re) 1)))
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
im
(+ im (* im re))
(+ im (* re (+ im (* 1/2 (* im re)))))
(+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
(* im (exp re))
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(* 1/6 (pow re 3))
(* (pow re 3) (+ 1/6 (* 1/2 (/ 1 re))))
(* (pow re 3) (+ 1/6 (+ (* 1/2 (/ 1 re)) (/ 1 (pow re 2)))))
(* (pow re 3) (+ 1/6 (+ (* 1/2 (/ 1 re)) (+ (/ 1 (pow re 2)) (/ 1 (pow re 3))))))
(* 1/6 (pow re 3))
(* (pow re 3) (+ 1/6 (* 1/2 (/ 1 re))))
(* -1 (* (pow re 3) (- (* -1 (/ (+ 1/2 (/ 1 re)) re)) 1/6)))
(* -1 (* (pow re 3) (- (* -1 (/ (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))) re)) 1/6)))
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
1
(+ 1 re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
(exp re)
1
(+ 1 re)
(+ 1 re)
(+ 1 re)
re
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
re
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
(* re (+ 1 (/ 1 re)))
im
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(+ (sin im) (* re (sin im)))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* im (exp re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
(* (exp re) (sin im))
im
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
im
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(* -1/5040 (pow im 7))
(* (pow im 7) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(* (pow im 7) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))
(* (pow im 7) (- (+ (* 1/120 (/ 1 (pow im 2))) (/ 1 (pow im 6))) (+ 1/5040 (/ 1/6 (pow im 4)))))
(* -1/5040 (pow im 7))
(* -1 (* (pow im 7) (- 1/5040 (* 1/120 (/ 1 (pow im 2))))))
(* -1 (* (pow im 7) (- (+ 1/5040 (/ 1/6 (pow im 4))) (* 1/120 (/ 1 (pow im 2))))))
(* -1 (* (pow im 7) (- (+ 1/5040 (/ 1/6 (pow im 4))) (+ (* 1/120 (/ 1 (pow im 2))) (/ 1 (pow im 6))))))
-1/6
(- (* 1/120 (pow im 2)) 1/6)
(- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6)
(- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6)
(* -1/5040 (pow im 4))
(* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))
(* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))
(* -1/5040 (pow im 4))
(* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))
(* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))
im
(* im (+ 1 (* -1/6 (pow im 2))))
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
(sin im)
1/2
(+ 1/2 (* 1/6 re))
(+ 1/2 (* 1/6 re))
(+ 1/2 (* 1/6 re))
(* 1/6 re)
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(* 1/6 re)
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
-1/6
(- (* 1/120 (pow im 2)) 1/6)
(- (* 1/120 (pow im 2)) 1/6)
(- (* 1/120 (pow im 2)) 1/6)
(* 1/120 (pow im 2))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(* 1/120 (pow im 2))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(pow im 3)
(* 1/120 im)
(* im (+ 1/120 (* -1/5040 (pow im 2))))
(* im (+ 1/120 (* -1/5040 (pow im 2))))
(* im (+ 1/120 (* -1/5040 (pow im 2))))
(* -1/5040 (pow im 3))
(* (pow im 3) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(* (pow im 3) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(* (pow im 3) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(* -1/5040 (pow im 3))
(* -1 (* (pow im 3) (- 1/5040 (* 1/120 (/ 1 (pow im 2))))))
(* -1 (* (pow im 3) (- 1/5040 (* 1/120 (/ 1 (pow im 2))))))
(* -1 (* (pow im 3) (- 1/5040 (* 1/120 (/ 1 (pow im 2))))))
1/120
(+ 1/120 (* -1/5040 (pow im 2)))
(+ 1/120 (* -1/5040 (pow im 2)))
(+ 1/120 (* -1/5040 (pow im 2)))
(* -1/5040 (pow im 2))
(* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(* -1/5040 (pow im 2))
(* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))

Outputs
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
re
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
re
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (+.f64 #s(literal 1 binary64) re) (sin.f64 im))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 (exp.f64 re) (fma.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 im (.f64 im (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
-1
#s(literal -1 binary64)
(- (pow re 2) 1)
(fma.f64 re re #s(literal -1 binary64))
(- (pow re 2) 1)
(fma.f64 re re #s(literal -1 binary64))
(- (pow re 2) 1)
(fma.f64 re re #s(literal -1 binary64))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (- 1 (/ 1 (pow re 2))))
(fma.f64 re re #s(literal -1 binary64))
(* (pow re 2) (- 1 (/ 1 (pow re 2))))
(fma.f64 re re #s(literal -1 binary64))
(* (pow re 2) (- 1 (/ 1 (pow re 2))))
(fma.f64 re re #s(literal -1 binary64))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (- 1 (/ 1 (pow re 2))))
(fma.f64 re re #s(literal -1 binary64))
(* (pow re 2) (- 1 (/ 1 (pow re 2))))
(fma.f64 re re #s(literal -1 binary64))
(* (pow re 2) (- 1 (/ 1 (pow re 2))))
(fma.f64 re re #s(literal -1 binary64))
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (+.f64 #s(literal 1 binary64) re) (sin.f64 im))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 (exp.f64 re) (fma.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 im (.f64 im (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
im
(+ im (* im re))
(fma.f64 re im im)
(+ im (* re (+ im (* 1/2 (* im re)))))
(fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)
(+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))
(fma.f64 re (fma.f64 (*.f64 re im) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) im) im)
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
im
(+ im (* im re))
(fma.f64 re im im)
(+ im (* im re))
(fma.f64 re im im)
(+ im (* im re))
(fma.f64 re im im)
(* im re)
(*.f64 re im)
(* re (+ im (/ im re)))
(fma.f64 re im im)
(* re (+ im (/ im re)))
(fma.f64 re im im)
(* re (+ im (/ im re)))
(fma.f64 re im im)
(* im re)
(*.f64 re im)
(* -1 (* re (+ (* -1 im) (* -1 (/ im re)))))
(fma.f64 re im im)
(* -1 (* re (+ (* -1 im) (* -1 (/ im re)))))
(fma.f64 re im im)
(* -1 (* re (+ (* -1 im) (* -1 (/ im re)))))
(fma.f64 re im im)
(* im (+ 1 re))
(fma.f64 re im im)
(* im (+ 1 re))
(fma.f64 re im im)
(* im (+ 1 re))
(fma.f64 re im im)
(* im (+ 1 re))
(fma.f64 re im im)
(* im (+ 1 re))
(fma.f64 re im im)
(* im (+ 1 re))
(fma.f64 re im im)
(* im (+ 1 re))
(fma.f64 re im im)
(* im (+ 1 re))
(fma.f64 re im im)
(* -1 (* im (- (* -1 re) 1)))
(fma.f64 re im im)
(* -1 (* im (- (* -1 re) 1)))
(fma.f64 re im im)
(* -1 (* im (- (* -1 re) 1)))
(fma.f64 re im im)
(* -1 (* im (- (* -1 re) 1)))
(fma.f64 re im im)
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (+.f64 #s(literal 1 binary64) re) (sin.f64 im))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 (exp.f64 re) (fma.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 im (.f64 im (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
im
(+ im (* im re))
(fma.f64 re im im)
(+ im (* re (+ im (* 1/2 (* im re)))))
(fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)
(+ im (* re (+ im (* re (+ (* 1/6 (* im re)) (* 1/2 im))))))
(fma.f64 re (fma.f64 (*.f64 re im) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) im) im)
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(* 1/6 (pow re 3))
(.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))
(* (pow re 3) (+ 1/6 (* 1/2 (/ 1 re))))
(.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))
(* (pow re 3) (+ 1/6 (+ (* 1/2 (/ 1 re)) (/ 1 (pow re 2)))))
(fma.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (*.f64 re re) re)
(* (pow re 3) (+ 1/6 (+ (* 1/2 (/ 1 re)) (+ (/ 1 (pow re 2)) (/ 1 (pow re 3))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(* 1/6 (pow re 3))
(.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))
(* (pow re 3) (+ 1/6 (* 1/2 (/ 1 re))))
(.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))
(* -1 (* (pow re 3) (- (* -1 (/ (+ 1/2 (/ 1 re)) re)) 1/6)))
(.f64 (.f64 re re) (*.f64 re (+.f64 #s(literal 1/6 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64)) re))))
(* -1 (* (pow re 3) (- (* -1 (/ (+ 1/2 (+ (/ 1 re) (/ 1 (pow re 2)))) re)) 1/6)))
(.f64 (.f64 re (.f64 re re)) (+.f64 #s(literal 1/6 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1 binary64) (.f64 re re)) (+.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64))) re)))
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (+.f64 #s(literal 1 binary64) re) (sin.f64 im))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 (exp.f64 re) (fma.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 im (.f64 im (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 (* re (+ 1 (* 1/2 re))))
(fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))
(+ 1 (* re (+ 1 (* re (+ 1/2 (* 1/6 re))))))
(fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
(exp re)
(exp.f64 re)
1
#s(literal 1 binary64)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
(+ 1 re)
(+.f64 #s(literal 1 binary64) re)
re
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
re
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
(* re (+ 1 (/ 1 re)))
(+.f64 #s(literal 1 binary64) re)
im
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(+ (sin im) (* re (sin im)))
(*.f64 (+.f64 #s(literal 1 binary64) re) (sin.f64 im))
(+ (sin im) (* re (+ (sin im) (* 1/2 (* re (sin im))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+ (sin im) (* re (+ (sin im) (* re (+ (* 1/6 (* re (sin im))) (* 1/2 (sin im)))))))
(*.f64 (sin.f64 im) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* im (exp re))
(*.f64 im (exp.f64 re))
(* im (+ (exp re) (* -1/6 (* (pow im 2) (exp re)))))
(.f64 (exp.f64 re) (fma.f64 #s(literal -1/6 binary64) (.f64 im (*.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* 1/120 (* (pow im 2) (exp re)))))))
(.f64 (exp.f64 re) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(* im (+ (exp re) (* (pow im 2) (+ (* -1/6 (exp re)) (* (pow im 2) (+ (* -1/5040 (* (pow im 2) (exp re))) (* 1/120 (exp re))))))))
(.f64 im (.f64 (exp.f64 re) (fma.f64 im (.f64 im (fma.f64 im (.f64 im (fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))) #s(literal 1 binary64))))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
(* (exp re) (sin im))
(*.f64 (sin.f64 im) (exp.f64 re))
im
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
im
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)
(* -1/5040 (pow im 7))
(*.f64 #s(literal -1/5040 binary64) (pow.f64 im #s(literal 7 binary64)))
(* (pow im 7) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(.f64 (pow.f64 im #s(literal 7 binary64)) (+.f64 #s(literal -1/5040 binary64) (/.f64 #s(literal 1/120 binary64) (.f64 im im))))
(* (pow im 7) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))
(.f64 (pow.f64 im #s(literal 7 binary64)) (+.f64 #s(literal -1/5040 binary64) (-.f64 (/.f64 #s(literal 1/120 binary64) (.f64 im im)) (/.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im (*.f64 im im)))))))
(* (pow im 7) (- (+ (* 1/120 (/ 1 (pow im 2))) (/ 1 (pow im 6))) (+ 1/5040 (/ 1/6 (pow im 4)))))
(.f64 (pow.f64 im #s(literal 7 binary64)) (+.f64 (/.f64 #s(literal 1/120 binary64) (.f64 im im)) (+.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 6 binary64))) (-.f64 #s(literal -1/5040 binary64) (/.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im (*.f64 im im))))))))
(* -1/5040 (pow im 7))
(*.f64 #s(literal -1/5040 binary64) (pow.f64 im #s(literal 7 binary64)))
(* -1 (* (pow im 7) (- 1/5040 (* 1/120 (/ 1 (pow im 2))))))
(.f64 (pow.f64 im #s(literal 7 binary64)) (+.f64 #s(literal -1/5040 binary64) (/.f64 #s(literal 1/120 binary64) (.f64 im im))))
(* -1 (* (pow im 7) (- (+ 1/5040 (/ 1/6 (pow im 4))) (* 1/120 (/ 1 (pow im 2))))))
(.f64 (pow.f64 im #s(literal 7 binary64)) (+.f64 #s(literal -1/5040 binary64) (-.f64 (/.f64 #s(literal 1/120 binary64) (.f64 im im)) (/.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im (*.f64 im im)))))))
(* -1 (* (pow im 7) (- (+ 1/5040 (/ 1/6 (pow im 4))) (+ (* 1/120 (/ 1 (pow im 2))) (/ 1 (pow im 6))))))
(.f64 (pow.f64 im #s(literal 7 binary64)) (+.f64 (/.f64 #s(literal 1/120 binary64) (.f64 im im)) (+.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 6 binary64))) (-.f64 #s(literal -1/5040 binary64) (/.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im (*.f64 im im))))))))
-1/6
#s(literal -1/6 binary64)
(- (* 1/120 (pow im 2)) 1/6)
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6)
(fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))
(- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6)
(fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))
(* -1/5040 (pow im 4))
(.f64 im (.f64 #s(literal -1/5040 binary64) (.f64 im (.f64 im im))))
(* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(.f64 (+.f64 #s(literal -1/5040 binary64) (/.f64 #s(literal 1/120 binary64) (.f64 im im))) (.f64 im (.f64 im (*.f64 im im))))
(* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))
(.f64 (.f64 im (.f64 im (.f64 im im))) (+.f64 #s(literal -1/5040 binary64) (-.f64 (/.f64 #s(literal 1/120 binary64) (.f64 im im)) (/.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im (.f64 im im)))))))
(* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))
(.f64 (.f64 im (.f64 im (.f64 im im))) (+.f64 #s(literal -1/5040 binary64) (-.f64 (/.f64 #s(literal 1/120 binary64) (.f64 im im)) (/.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im (.f64 im im)))))))
(* -1/5040 (pow im 4))
(.f64 im (.f64 #s(literal -1/5040 binary64) (.f64 im (.f64 im im))))
(* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(.f64 (+.f64 #s(literal -1/5040 binary64) (/.f64 #s(literal 1/120 binary64) (.f64 im im))) (.f64 im (.f64 im (*.f64 im im))))
(* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))
(.f64 (.f64 im (.f64 im (.f64 im im))) (+.f64 #s(literal -1/5040 binary64) (-.f64 (/.f64 #s(literal 1/120 binary64) (.f64 im im)) (/.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im (.f64 im im)))))))
(* (pow im 4) (- (* 1/120 (/ 1 (pow im 2))) (+ 1/5040 (/ 1/6 (pow im 4)))))
(.f64 (.f64 im (.f64 im (.f64 im im))) (+.f64 #s(literal -1/5040 binary64) (-.f64 (/.f64 #s(literal 1/120 binary64) (.f64 im im)) (/.f64 #s(literal 1/6 binary64) (.f64 im (.f64 im (.f64 im im)))))))
im
(* im (+ 1 (* -1/6 (pow im 2))))
(fma.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* 1/120 (pow im 2)) 1/6))))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)
(* im (+ 1 (* (pow im 2) (- (* (pow im 2) (+ 1/120 (* -1/5040 (pow im 2)))) 1/6))))
(fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
(sin im)
(sin.f64 im)
1/2
#s(literal 1/2 binary64)
(+ 1/2 (* 1/6 re))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(+ 1/2 (* 1/6 re))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(+ 1/2 (* 1/6 re))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(* 1/6 re)
(*.f64 re #s(literal 1/6 binary64))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(* 1/6 re)
(*.f64 re #s(literal 1/6 binary64))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
(* re (+ 1/6 (* 1/2 (/ 1 re))))
(fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))
-1/6
#s(literal -1/6 binary64)
(- (* 1/120 (pow im 2)) 1/6)
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(- (* 1/120 (pow im 2)) 1/6)
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(- (* 1/120 (pow im 2)) 1/6)
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(* 1/120 (pow im 2))
(.f64 (.f64 im im) #s(literal 1/120 binary64))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(* 1/120 (pow im 2))
(.f64 (.f64 im im) #s(literal 1/120 binary64))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(* (pow im 2) (- 1/120 (* 1/6 (/ 1 (pow im 2)))))
(fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(pow im 3)
(.f64 im (.f64 im im))
(* 1/120 im)
(*.f64 im #s(literal 1/120 binary64))
(* im (+ 1/120 (* -1/5040 (pow im 2))))
(.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))
(* im (+ 1/120 (* -1/5040 (pow im 2))))
(.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))
(* im (+ 1/120 (* -1/5040 (pow im 2))))
(.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))
(* -1/5040 (pow im 3))
(.f64 #s(literal -1/5040 binary64) (.f64 im (*.f64 im im)))
(* (pow im 3) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))
(* (pow im 3) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))
(* (pow im 3) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))
(* -1/5040 (pow im 3))
(.f64 #s(literal -1/5040 binary64) (.f64 im (*.f64 im im)))
(* -1 (* (pow im 3) (- 1/5040 (* 1/120 (/ 1 (pow im 2))))))
(.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))
(* -1 (* (pow im 3) (- 1/5040 (* 1/120 (/ 1 (pow im 2))))))
(.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))
(* -1 (* (pow im 3) (- 1/5040 (* 1/120 (/ 1 (pow im 2))))))
(.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))
1/120
#s(literal 1/120 binary64)
(+ 1/120 (* -1/5040 (pow im 2)))
(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))
(+ 1/120 (* -1/5040 (pow im 2)))
(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))
(+ 1/120 (* -1/5040 (pow im 2)))
(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))
(* -1/5040 (pow im 2))
(.f64 (.f64 im im) #s(literal -1/5040 binary64))
(* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))
(* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))
(* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))
(* -1/5040 (pow im 2))
(.f64 (.f64 im im) #s(literal -1/5040 binary64))
(* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))
(* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))
(* (pow im 2) (- (* 1/120 (/ 1 (pow im 2))) 1/5040))
(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))

rewrite328.0ms (2%)

Memory

9.7MiB live, 683.0MiB allocated

Rules

5 208×	`lower-fma.f32`
5 192×	`lower-fma.f64`
4 506×	`lower-/.f32`
4 504×	`lower-/.f64`
4 206×	`lower-*.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	47	304
0	74	302
1	269	277
2	1863	277
0	8377	269

Stop Event

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

Counts

25 → 501

Calls

Call 1

Inputs
(/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))
(*.f64 #s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (sin.f64 im))
#s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))
(fma.f64 re re #s(literal -1 binary64))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* im (exp re)) (fma.f64 re im im))
(fma.f64 re im im)
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))
#s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(+.f64 re #s(literal 1 binary64))
#s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im))
(fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)
(fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))
(sin.f64 im)
#s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64))
#s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64))
(.f64 im (.f64 im im))
(.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64)))
(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))

Outputs
(+.f64 re #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) re)
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))) #s(literal -1 binary64)))
(-.f64 re #s(literal -1 binary64))
(-.f64 (/.f64 (*.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))
(-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)) (/.f64 (*.f64 re re) (-.f64 #s(literal 1 binary64) re)))
(-.f64 (/.f64 #s(literal 0 binary64) (-.f64 #s(literal 1 binary64) re)) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (-.f64 #s(literal 1 binary64) re)))
(-.f64 (/.f64 (/.f64 (.f64 re (.f64 re (*.f64 re re))) (fma.f64 re re #s(literal 1 binary64))) (+.f64 re #s(literal -1 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))) (+.f64 re #s(literal -1 binary64))))
(-.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64)))))
(-.f64 (/.f64 (.f64 re (.f64 re re)) (fma.f64 re re (+.f64 #s(literal 1 binary64) (.f64 re #s(literal -1 binary64))))) (/.f64 #s(literal -1 binary64) (fma.f64 re re (+.f64 #s(literal 1 binary64) (.f64 re #s(literal -1 binary64))))))
(fma.f64 re #s(literal 1 binary64) #s(literal 1 binary64))
(fma.f64 #s(literal 1 binary64) re #s(literal 1 binary64))
(neg.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (-.f64 #s(literal 1 binary64) re)))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (+.f64 re #s(literal -1 binary64))) (+.f64 re #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re re) re)) (fma.f64 re (.f64 re re) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 re #s(literal -1 binary64)) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re)))) (fma.f64 (.f64 re re) (.f64 re (.f64 re (*.f64 re re))) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64))) (fma.f64 (.f64 re re) (*.f64 re re) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re))) (+.f64 re #s(literal -1 binary64))) (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (fma.f64 re re #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64))) (.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re re (+.f64 #s(literal 1 binary64) (.f64 re #s(literal -1 binary64)))) (-.f64 (.f64 re (*.f64 re re)) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 1 binary64) (*.f64 re re))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 re #s(literal -1 binary64)) (*.f64 (fma.f64 re re #s(literal -1 binary64)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re))) (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (*.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re re #s(literal 1 binary64)) (.f64 (fma.f64 (.f64 re re) (*.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))))
(/.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64))) (-.f64 #s(literal 1 binary64) re))
(/.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64)) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))
(/.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re re) re)))
(/.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (.f64 (+.f64 re #s(literal -1 binary64)) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re)))))
(/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))
(/.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) (*.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) #s(literal 1 binary64)) (.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re))) (+.f64 re #s(literal -1 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) #s(literal 1 binary64)) (.f64 (fma.f64 re re #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64))))
(/.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64))) (neg.f64 (.f64 (+.f64 re #s(literal -1 binary64)) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re))))))
(/.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64))) (neg.f64 (*.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64)))) (neg.f64 (-.f64 #s(literal 1 binary64) re)))
(/.f64 (neg.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64))) (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(/.f64 (neg.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64))) (neg.f64 (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re re) re))))
(/.f64 (-.f64 (.f64 re (.f64 re re)) #s(literal -1 binary64)) (fma.f64 re re (+.f64 #s(literal 1 binary64) (*.f64 re #s(literal -1 binary64)))))
(/.f64 (-.f64 #s(literal 1 binary64) (*.f64 re re)) (-.f64 #s(literal 1 binary64) re))
(/.f64 (*.f64 (fma.f64 re re #s(literal -1 binary64)) #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64)))
(/.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re))) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re))))
(/.f64 (.f64 (fma.f64 (.f64 re re) (*.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re))) (fma.f64 re re #s(literal 1 binary64)))
(/.f64 (-.f64 (.f64 (.f64 re re) (-.f64 #s(literal 1 binary64) re)) (.f64 (+.f64 re #s(literal -1 binary64)) #s(literal -1 binary64))) (.f64 (+.f64 re #s(literal -1 binary64)) (-.f64 #s(literal 1 binary64) re)))
(/.f64 (-.f64 (.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (+.f64 re #s(literal -1 binary64))) (*.f64 (+.f64 re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) #s(literal 1 binary64))) (neg.f64 (.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re))) (+.f64 re #s(literal -1 binary64)))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) #s(literal 1 binary64))) (neg.f64 (.f64 (fma.f64 re re #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64)))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64))))) (neg.f64 (neg.f64 (-.f64 #s(literal 1 binary64) re))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64)))) (neg.f64 (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))))
(/.f64 (neg.f64 (-.f64 (.f64 re (.f64 re re)) #s(literal -1 binary64))) (neg.f64 (fma.f64 re re (+.f64 #s(literal 1 binary64) (*.f64 re #s(literal -1 binary64))))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (*.f64 re re))) (neg.f64 (-.f64 #s(literal 1 binary64) re)))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re #s(literal -1 binary64)) #s(literal 1 binary64))) (-.f64 #s(literal 1 binary64) re))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))) (neg.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re)))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 re re) (*.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))) (neg.f64 (fma.f64 re re #s(literal 1 binary64))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (fma.f64 (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)) (.f64 (/.f64 (*.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))))))
(*.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))
(*.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)))
(.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (-.f64 (*.f64 re re) re))))
(.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re #s(literal -1 binary64)) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re))))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))) (/.f64 (+.f64 re #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
(*.f64 (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)) (fma.f64 re re #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)) (/.f64 (+.f64 re #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
(*.f64 (fma.f64 re re #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))
(*.f64 (+.f64 re #s(literal 1 binary64)) (/.f64 (+.f64 re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))
(.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64)))))
(*.f64 (fma.f64 re re #s(literal 1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
(.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re))) (+.f64 re #s(literal -1 binary64)))))
(.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 re re #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64)))))
(*.f64 (neg.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64)))) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))
(.f64 (neg.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))))
(.f64 (-.f64 (.f64 re (.f64 re re)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re re (+.f64 #s(literal 1 binary64) (.f64 re #s(literal -1 binary64))))))
(.f64 (-.f64 #s(literal 1 binary64) (.f64 re re)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)))
(.f64 (.f64 (fma.f64 re re #s(literal -1 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))
(.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re)))))
(.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))))
(.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))
(.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))))
(*.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re re #s(literal -1 binary64))) (+.f64 re #s(literal 1 binary64)))
(.f64 (pow.f64 (/.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re)))))
(.f64 (pow.f64 (/.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 (.f64 re re) (*.f64 re re) #s(literal -1 binary64))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))))
(*.f64 (/.f64 (+.f64 re #s(literal 1 binary64)) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 1 binary64) re) (+.f64 re #s(literal -1 binary64))))
(*.f64 (/.f64 (neg.f64 (+.f64 re #s(literal 1 binary64))) #s(literal -1 binary64)) (/.f64 (+.f64 re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))
(.f64 (/.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (/.f64 (+.f64 re #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))))
(.f64 (/.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re)))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))))
(.f64 (/.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (fma.f64 re re #s(literal -1 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
(.f64 (/.f64 (+.f64 re #s(literal 1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (/.f64 (+.f64 re #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))))
(.f64 (/.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))))
(*.f64 (/.f64 (fma.f64 re re #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64))) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64))))
(*.f64 (sin.f64 im) #s(approx (exp re) (+.f64 re #s(literal 1 binary64))))
(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(+.f64 #s(literal -1 binary64) (*.f64 re re))
(+.f64 (*.f64 re re) #s(literal -1 binary64))
(-.f64 (*.f64 re re) #s(literal 1 binary64))
(-.f64 (/.f64 (.f64 re (.f64 re (*.f64 re re))) (fma.f64 re re #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))))
(-.f64 (/.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (fma.f64 re (.f64 re (.f64 re re)) (+.f64 #s(literal 1 binary64) (.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (+.f64 #s(literal 1 binary64) (*.f64 re re)))))
(-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal -1 binary64) (.f64 re re))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (-.f64 #s(literal -1 binary64) (*.f64 re re))))
(expm1.f64 (*.f64 #s(literal 2 binary64) (log.f64 re)))
(fma.f64 re re #s(literal -1 binary64))
(fma.f64 #s(literal 1 binary64) (*.f64 re re) #s(literal -1 binary64))
(fma.f64 (*.f64 re re) #s(literal 1 binary64) #s(literal -1 binary64))
(fma.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal -1 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 #s(literal -1 binary64) (.f64 re re)))) (fma.f64 (.f64 re re) (.f64 re (.f64 re (*.f64 re re))) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (.f64 re (.f64 re re)) (+.f64 #s(literal 1 binary64) (.f64 re re))) (-.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal -1 binary64) (.f64 re re)) (-.f64 #s(literal 1 binary64) (.f64 re (.f64 re (.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re) (.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 re #s(literal -1 binary64)) (*.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))))
(/.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re))))
(/.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 #s(literal -1 binary64) (*.f64 re re)))))
(/.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64)))
(/.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64))) (neg.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re)))))
(/.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64))) (neg.f64 (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 #s(literal -1 binary64) (*.f64 re re))))))
(/.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64))) (neg.f64 (fma.f64 re re #s(literal 1 binary64))))
(/.f64 (-.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1 binary64)) (fma.f64 re (.f64 re (.f64 re re)) (+.f64 #s(literal 1 binary64) (.f64 re re))))
(/.f64 (-.f64 #s(literal 1 binary64) (.f64 re (.f64 re (.f64 re re)))) (-.f64 #s(literal -1 binary64) (.f64 re re)))
(/.f64 (.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64))) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))
(/.f64 (*.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))) (+.f64 re #s(literal -1 binary64)))
(/.f64 (-.f64 (.f64 (.f64 re (.f64 re (.f64 re re))) (fma.f64 re re #s(literal 1 binary64))) (.f64 (fma.f64 re re #s(literal 1 binary64)) #s(literal 1 binary64))) (.f64 (fma.f64 re re #s(literal 1 binary64)) (fma.f64 re re #s(literal 1 binary64))))
(/.f64 (neg.f64 (-.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1 binary64))) (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (+.f64 #s(literal 1 binary64) (.f64 re re)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)))) (neg.f64 (neg.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)))) (neg.f64 (neg.f64 (fma.f64 re re #s(literal 1 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (.f64 re (.f64 re (.f64 re re))))) (neg.f64 (-.f64 #s(literal -1 binary64) (.f64 re re))))
(/.f64 (neg.f64 (.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64)))) (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (-.f64 #s(literal 1 binary64) re))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (fma.f64 re re #s(literal 1 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (fma.f64 re re #s(literal 1 binary64))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (fma.f64 re re #s(literal 1 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))) (.f64 (/.f64 (.f64 re (.f64 re (*.f64 re re))) (fma.f64 re re #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal -1 binary64))) #s(literal -1 binary64))
(*.f64 (+.f64 re #s(literal -1 binary64)) (+.f64 re #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal -1 binary64)))
(.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re)))))
(.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 #s(literal -1 binary64) (.f64 re re))))))
(*.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64)))
(.f64 (fma.f64 (.f64 re re) (*.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))))
(.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re))))))
(.f64 (neg.f64 (fma.f64 (.f64 re re) (*.f64 re re) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re re #s(literal 1 binary64)))))
(.f64 (-.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (+.f64 #s(literal 1 binary64) (*.f64 re re)))))
(.f64 (-.f64 #s(literal 1 binary64) (.f64 re (.f64 re (.f64 re re)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal -1 binary64) (*.f64 re re))))
(.f64 (.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(.f64 (.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))
(.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (/.f64 (+.f64 re #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))))
(*.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re re #s(literal -1 binary64))) (/.f64 (+.f64 re #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* im (exp re)) (fma.f64 re im im))
(+.f64 im (*.f64 re im))
(+.f64 (*.f64 re im) im)
(-.f64 (/.f64 (.f64 re (.f64 re (.f64 im im))) (-.f64 (.f64 re im) im)) (/.f64 (.f64 im im) (-.f64 (.f64 re im) im)))
(-.f64 (/.f64 (.f64 im im) (-.f64 im (.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 im im))) (-.f64 im (.f64 re im))))
(fma.f64 re im im)
(fma.f64 im re im)
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re im im))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re im im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re im im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im im (-.f64 (.f64 re (.f64 re (.f64 im im))) (.f64 re (.f64 im im)))) (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 im (.f64 re im)) (-.f64 (.f64 im im) (.f64 re (.f64 re (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re) (.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 re #s(literal -1 binary64)) (*.f64 (fma.f64 re re #s(literal -1 binary64)) im)))
(/.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (.f64 re im)))))
(/.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (fma.f64 im im (-.f64 (.f64 re (.f64 re (.f64 im im))) (.f64 re (*.f64 im im)))))
(/.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im)) (-.f64 (*.f64 re im) im))
(/.f64 (neg.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re))))) (neg.f64 (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (.f64 re im))))))
(/.f64 (neg.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re))))) (neg.f64 (fma.f64 im im (-.f64 (.f64 re (.f64 re (.f64 im im))) (.f64 re (*.f64 im im))))))
(/.f64 (neg.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im))) (neg.f64 (-.f64 (*.f64 re im) im)))
(/.f64 (-.f64 (.f64 im im) (.f64 re (.f64 re (.f64 im im)))) (-.f64 im (*.f64 re im)))
(/.f64 (.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) im) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))
(/.f64 (*.f64 (fma.f64 re re #s(literal -1 binary64)) im) (+.f64 re #s(literal -1 binary64)))
(/.f64 (-.f64 (.f64 (.f64 re (.f64 re (.f64 im im))) (-.f64 (.f64 re im) im)) (.f64 (-.f64 (.f64 re im) im) (.f64 im im))) (.f64 (-.f64 (.f64 re im) im) (-.f64 (*.f64 re im) im)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))))) (neg.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (.f64 re im)))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im)))) (neg.f64 (neg.f64 (-.f64 (*.f64 re im) im))))
(/.f64 (neg.f64 (-.f64 (.f64 im im) (.f64 re (.f64 re (.f64 im im))))) (neg.f64 (-.f64 im (*.f64 re im))))
(/.f64 (neg.f64 (.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) im)) (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re #s(literal -1 binary64)) im)) (-.f64 #s(literal 1 binary64) re))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 re (.f64 re (.f64 im im))) (-.f64 (.f64 re im) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (.f64 im im) (-.f64 (.f64 re im) im)) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 re (.f64 re (.f64 im im))) (-.f64 (.f64 re im) im)) (/.f64 (.f64 re (.f64 re (.f64 im im))) (-.f64 (.f64 re im) im)) (fma.f64 (/.f64 (.f64 im im) (-.f64 (.f64 re im) im)) (/.f64 (.f64 im im) (-.f64 (.f64 re im) im)) (.f64 (/.f64 (.f64 re (.f64 re (.f64 im im))) (-.f64 (.f64 re im) im)) (/.f64 (.f64 im im) (-.f64 (*.f64 re im) im))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re im im)) #s(literal -1 binary64))
(*.f64 im (+.f64 re #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (fma.f64 re im im))
(.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (*.f64 re im))))))
(.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 im im (-.f64 (.f64 re (.f64 re (.f64 im im))) (.f64 re (.f64 im im))))))
(*.f64 (+.f64 re #s(literal 1 binary64)) im)
(.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re im) im)))
(.f64 (neg.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (*.f64 re im)))))))
(.f64 (neg.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (.f64 re im) im))))
(.f64 (-.f64 (.f64 im im) (.f64 re (.f64 re (.f64 im im)))) (/.f64 #s(literal 1 binary64) (-.f64 im (.f64 re im))))
(.f64 (.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64)) im) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(.f64 (.f64 (fma.f64 re re #s(literal -1 binary64)) im) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))
(.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))))
(*.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re re #s(literal -1 binary64))) (/.f64 im (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) im)
#s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(+.f64 #s(literal 1 binary64) (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re))
(+.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re) #s(literal 1 binary64))
(+.f64 (.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re)) (+.f64 re #s(literal 1 binary64)))
(+.f64 (+.f64 #s(literal 1 binary64) (.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re))) re)
(-.f64 (/.f64 (.f64 (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))))
(-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re))) (/.f64 (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) (-.f64 #s(literal 1 binary64) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re))))
(fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 re (.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64))) (+.f64 re #s(literal 1 binary64)))
(fma.f64 re (.f64 (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) (+.f64 re #s(literal 1 binary64)))
(fma.f64 #s(literal 1 binary64) (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re) #s(literal 1 binary64))
(fma.f64 (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) re #s(literal 1 binary64))
(fma.f64 (.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64))) re (+.f64 re #s(literal 1 binary64)))
(fma.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re) #s(literal 1 binary64) #s(literal 1 binary64))
(fma.f64 (.f64 re re) #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (+.f64 re #s(literal 1 binary64)))
(fma.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)))) (.f64 re (.f64 re re))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re)) (.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re)) (-.f64 (.f64 re re) (.f64 (.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re)) re)))) #s(literal 1 binary64))
(fma.f64 (-.f64 (.f64 (.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re)) (.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re))) (.f64 re re)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re)) re)) #s(literal 1 binary64))
(fma.f64 (.f64 re (fma.f64 (.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64))) (.f64 re (.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64))))) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re)) #s(literal 1 binary64)) (.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64))))) #s(literal 1 binary64))
(fma.f64 (.f64 re (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64))
(fma.f64 (.f64 (fma.f64 (.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64))) (.f64 re (.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64))))) #s(literal 1 binary64)) re) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re)) #s(literal 1 binary64)) (.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64))))) #s(literal 1 binary64))
(fma.f64 (.f64 (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re)) #s(literal -1 binary64)) re) (/.f64 #s(literal 1 binary64) (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (-.f64 (.f64 (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re))) (fma.f64 (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 1 binary64) (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re)))))
(/.f64 (fma.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal 1 binary64)) (-.f64 (fma.f64 (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (.f64 re (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal 1 binary64)) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re)))
(/.f64 (fma.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal 1 binary64)) (+.f64 #s(literal 1 binary64) (-.f64 (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re))))
(/.f64 (fma.f64 (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (.f64 re (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal -1 binary64)) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))
(/.f64 (neg.f64 (fma.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal 1 binary64))) (neg.f64 (-.f64 (fma.f64 (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (.f64 re (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal 1 binary64)) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re))))
(/.f64 (neg.f64 (fma.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal 1 binary64))) (neg.f64 (+.f64 #s(literal 1 binary64) (-.f64 (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re)))))
(/.f64 (neg.f64 (fma.f64 (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (.f64 re (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal -1 binary64))) (neg.f64 (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))))
(/.f64 (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re))) (-.f64 #s(literal 1 binary64) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re)))
(/.f64 (-.f64 (.f64 (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (.f64 (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)) #s(literal 1 binary64))) (.f64 (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal 1 binary64)))) (neg.f64 (neg.f64 (-.f64 (fma.f64 (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (.f64 re (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal 1 binary64)) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (.f64 re (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal -1 binary64)))) (neg.f64 (neg.f64 (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)))) (neg.f64 (-.f64 #s(literal 1 binary64) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re))))
(/.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)))) (pow.f64 (+.f64 re #s(literal 1 binary64)) #s(literal 3 binary64))) (fma.f64 (.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re)) (.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re)) (-.f64 (.f64 (+.f64 re #s(literal 1 binary64)) (+.f64 re #s(literal 1 binary64))) (.f64 (.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re)) (+.f64 re #s(literal 1 binary64))))))
(/.f64 (+.f64 (pow.f64 (+.f64 #s(literal 1 binary64) (.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re))) #s(literal 3 binary64)) (.f64 re (.f64 re re))) (fma.f64 (+.f64 #s(literal 1 binary64) (.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re))) (+.f64 #s(literal 1 binary64) (.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re))) (-.f64 (.f64 re re) (.f64 (+.f64 #s(literal 1 binary64) (.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re))) re))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 (.f64 (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (.f64 (/.f64 (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(literal -1 binary64))
(.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))
(.f64 (fma.f64 (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (.f64 re (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal 1 binary64)) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re))))
(.f64 (fma.f64 (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (-.f64 (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re)))))
(.f64 (fma.f64 (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (.f64 re (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64))))
(.f64 (neg.f64 (fma.f64 (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (.f64 re (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal 1 binary64)) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re)))))
(.f64 (neg.f64 (fma.f64 (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) (.f64 re (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re)) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))))
(.f64 (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 #s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (.f64 re re) re))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (fma.f64 #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) (*.f64 re re) re))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (.f64 im im) (.f64 im #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64))) im)))
(.f64 #s(approx (sin im) (fma.f64 (.f64 im im) (.f64 im #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64))) im)) #s(approx (exp re) (+.f64 re #s(literal 1 binary64))))
#s(approx (exp re) (+.f64 re #s(literal 1 binary64)))
(+.f64 re #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) re)
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))) #s(literal -1 binary64)))
(-.f64 re #s(literal -1 binary64))
(-.f64 (/.f64 (*.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))
(-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)) (/.f64 (*.f64 re re) (-.f64 #s(literal 1 binary64) re)))
(-.f64 (/.f64 #s(literal 0 binary64) (-.f64 #s(literal 1 binary64) re)) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (-.f64 #s(literal 1 binary64) re)))
(-.f64 (/.f64 (/.f64 (.f64 re (.f64 re (*.f64 re re))) (fma.f64 re re #s(literal 1 binary64))) (+.f64 re #s(literal -1 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))) (+.f64 re #s(literal -1 binary64))))
(-.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64)))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64)))))
(-.f64 (/.f64 (.f64 re (.f64 re re)) (fma.f64 re re (+.f64 #s(literal 1 binary64) (.f64 re #s(literal -1 binary64))))) (/.f64 #s(literal -1 binary64) (fma.f64 re re (+.f64 #s(literal 1 binary64) (.f64 re #s(literal -1 binary64))))))
(fma.f64 re #s(literal 1 binary64) #s(literal 1 binary64))
(fma.f64 #s(literal 1 binary64) re #s(literal 1 binary64))
(neg.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (-.f64 #s(literal 1 binary64) re)))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (+.f64 re #s(literal -1 binary64))) (+.f64 re #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re re) re)) (fma.f64 re (.f64 re re) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 re #s(literal -1 binary64)) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re)))) (fma.f64 (.f64 re re) (.f64 re (.f64 re (*.f64 re re))) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64))) (fma.f64 (.f64 re re) (*.f64 re re) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re))) (+.f64 re #s(literal -1 binary64))) (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (fma.f64 re re #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64))) (.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re re (+.f64 #s(literal 1 binary64) (.f64 re #s(literal -1 binary64)))) (-.f64 (.f64 re (*.f64 re re)) #s(literal -1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 1 binary64) re) (-.f64 #s(literal 1 binary64) (*.f64 re re))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 re #s(literal -1 binary64)) (*.f64 (fma.f64 re re #s(literal -1 binary64)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re))) (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (*.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re re #s(literal 1 binary64)) (.f64 (fma.f64 (.f64 re re) (*.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))))
(/.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64))) (-.f64 #s(literal 1 binary64) re))
(/.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64)) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))
(/.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re re) re)))
(/.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (.f64 (+.f64 re #s(literal -1 binary64)) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re)))))
(/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))
(/.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) (*.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) #s(literal 1 binary64)) (.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re))) (+.f64 re #s(literal -1 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) #s(literal 1 binary64)) (.f64 (fma.f64 re re #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64))))
(/.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64))) (neg.f64 (.f64 (+.f64 re #s(literal -1 binary64)) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re))))))
(/.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64))) (neg.f64 (*.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64)))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64)))) (neg.f64 (-.f64 #s(literal 1 binary64) re)))
(/.f64 (neg.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64))) (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(/.f64 (neg.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64))) (neg.f64 (+.f64 #s(literal 1 binary64) (-.f64 (.f64 re re) re))))
(/.f64 (-.f64 (.f64 re (.f64 re re)) #s(literal -1 binary64)) (fma.f64 re re (+.f64 #s(literal 1 binary64) (*.f64 re #s(literal -1 binary64)))))
(/.f64 (-.f64 #s(literal 1 binary64) (*.f64 re re)) (-.f64 #s(literal 1 binary64) re))
(/.f64 (*.f64 (fma.f64 re re #s(literal -1 binary64)) #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64)))
(/.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re))) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re))))
(/.f64 (.f64 (fma.f64 (.f64 re re) (*.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re))) (fma.f64 re re #s(literal 1 binary64)))
(/.f64 (-.f64 (.f64 (.f64 re re) (-.f64 #s(literal 1 binary64) re)) (.f64 (+.f64 re #s(literal -1 binary64)) #s(literal -1 binary64))) (.f64 (+.f64 re #s(literal -1 binary64)) (-.f64 #s(literal 1 binary64) re)))
(/.f64 (-.f64 (.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (+.f64 re #s(literal -1 binary64))) (*.f64 (+.f64 re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) #s(literal 1 binary64))) (neg.f64 (.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re))) (+.f64 re #s(literal -1 binary64)))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) #s(literal 1 binary64))) (neg.f64 (.f64 (fma.f64 re re #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64)))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64))))) (neg.f64 (neg.f64 (-.f64 #s(literal 1 binary64) re))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re (*.f64 re re) #s(literal 1 binary64)))) (neg.f64 (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))))
(/.f64 (neg.f64 (-.f64 (.f64 re (.f64 re re)) #s(literal -1 binary64))) (neg.f64 (fma.f64 re re (+.f64 #s(literal 1 binary64) (*.f64 re #s(literal -1 binary64))))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (*.f64 re re))) (neg.f64 (-.f64 #s(literal 1 binary64) re)))
(/.f64 (neg.f64 (*.f64 (fma.f64 re re #s(literal -1 binary64)) #s(literal 1 binary64))) (-.f64 #s(literal 1 binary64) re))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))) (neg.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re)))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 re re) (*.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))) (neg.f64 (fma.f64 re re #s(literal 1 binary64))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 (.f64 re re) (+.f64 re #s(literal -1 binary64))) (fma.f64 (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)) (.f64 (/.f64 (*.f64 re re) (+.f64 re #s(literal -1 binary64))) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))))))
(*.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))
(*.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)))
(.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) re)))
(.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (-.f64 (*.f64 re re) re))))
(.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re #s(literal -1 binary64)) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re))))))
(*.f64 (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64))) (/.f64 (+.f64 re #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
(*.f64 (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)) (fma.f64 re re #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)) (/.f64 (+.f64 re #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
(*.f64 (fma.f64 re re #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))
(*.f64 (+.f64 re #s(literal 1 binary64)) (/.f64 (+.f64 re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))
(.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64)))))
(*.f64 (fma.f64 re re #s(literal 1 binary64)) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
(.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re))) (+.f64 re #s(literal -1 binary64)))))
(.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (fma.f64 re re #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64)))))
(*.f64 (neg.f64 (neg.f64 (fma.f64 re re #s(literal -1 binary64)))) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))
(.f64 (neg.f64 (fma.f64 re (.f64 re re) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 re re #s(literal 1 binary64)) re))))
(.f64 (-.f64 (.f64 re (.f64 re re)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re re (+.f64 #s(literal 1 binary64) (.f64 re #s(literal -1 binary64))))))
(.f64 (-.f64 #s(literal 1 binary64) (.f64 re re)) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) re)))
(.f64 (.f64 (fma.f64 re re #s(literal -1 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re)))
(.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re)))))
(.f64 (.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (-.f64 #s(literal 1 binary64) re))) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))))
(.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))
(.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))))
(*.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re re #s(literal -1 binary64))) (+.f64 re #s(literal 1 binary64)))
(.f64 (pow.f64 (/.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re)))))
(.f64 (pow.f64 (/.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 (.f64 re re) (*.f64 re re) #s(literal -1 binary64))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))))
(*.f64 (/.f64 (+.f64 re #s(literal 1 binary64)) #s(literal -1 binary64)) (/.f64 (-.f64 #s(literal 1 binary64) re) (+.f64 re #s(literal -1 binary64))))
(*.f64 (/.f64 (neg.f64 (+.f64 re #s(literal 1 binary64))) #s(literal -1 binary64)) (/.f64 (+.f64 re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64))))
(.f64 (/.f64 (+.f64 re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (/.f64 (+.f64 re #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))))
(.f64 (/.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (.f64 re re)))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))))
(.f64 (/.f64 (fma.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))) #s(literal -1 binary64)) (fma.f64 re re #s(literal -1 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal 1 binary64)) (.f64 #s(literal -1 binary64) (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (+.f64 re #s(literal 1 binary64)))))
(.f64 (/.f64 (+.f64 re #s(literal 1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (/.f64 (+.f64 re #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))))
(.f64 (/.f64 (fma.f64 (.f64 re re) (.f64 re re) #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (*.f64 re #s(literal -1 binary64))))))
(*.f64 (/.f64 (fma.f64 re re #s(literal 1 binary64)) (+.f64 re #s(literal -1 binary64))) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re re #s(literal 1 binary64))))
#s(approx (sin im) (fma.f64 (.f64 im im) (.f64 im #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64))) im))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)))
#s(approx (sin im) (fma.f64 im (.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im))
(+.f64 im (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))
(+.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)
(-.f64 (/.f64 (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)))
(-.f64 (/.f64 (.f64 im im) (-.f64 im (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (/.f64 (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (-.f64 im (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))))
(fma.f64 im (.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)
(fma.f64 (.f64 im im) (.f64 im (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)
(fma.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) im)
(fma.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)
(fma.f64 (.f64 im (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) (.f64 im im) im)
(fma.f64 (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 im im)) im im)
(fma.f64 (.f64 (.f64 im (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im) im im)
(fma.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) #s(literal -1/216 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal 1/36 binary64)) (.f64 (.f64 im im) (.f64 (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) im)
(fma.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal -1/36 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) im)
(fma.f64 (.f64 (fma.f64 (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) #s(literal -1/216 binary64)) (.f64 im (.f64 im im))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal 1/36 binary64)) (.f64 (.f64 im im) (.f64 (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) im)
(fma.f64 (.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal -1/36 binary64)) (.f64 im (.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) im)
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im im (-.f64 (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im im) (.f64 im im))))) (fma.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (.f64 im (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 im (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))) (-.f64 (.f64 im im) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))))))
(/.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (.f64 im (.f64 im im))) (fma.f64 im (-.f64 im (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))))))
(/.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (.f64 im (.f64 im im))) (fma.f64 im im (-.f64 (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im im) (*.f64 im im))))))
(/.f64 (.f64 (fma.f64 im (.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (.f64 im (.f64 im im)))) (neg.f64 (fma.f64 im (-.f64 im (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (.f64 im (.f64 im im)))) (neg.f64 (fma.f64 im im (-.f64 (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im im) (*.f64 im im)))))))
(/.f64 (neg.f64 (.f64 (fma.f64 im (.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im))) (neg.f64 (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)))
(/.f64 (-.f64 (.f64 im im) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))))) (-.f64 im (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))))
(/.f64 (-.f64 (.f64 (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) (.f64 (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im) (.f64 im im))) (.f64 (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (.f64 im (.f64 im im))))) (neg.f64 (neg.f64 (fma.f64 im (-.f64 im (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (fma.f64 im (.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)))) (neg.f64 (neg.f64 (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im))))
(/.f64 (neg.f64 (-.f64 (.f64 im im) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))))) (neg.f64 (-.f64 im (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (.f64 im im) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) (/.f64 (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) (fma.f64 (/.f64 (.f64 im im) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) (.f64 (/.f64 (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) #s(literal -1 binary64))
(.f64 #s(literal 1 binary64) (fma.f64 im (.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im))
(.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (.f64 im (.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))))))
(.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (.f64 im (.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 im im (-.f64 (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im im) (.f64 im im)))))))
(.f64 (.f64 (fma.f64 im (.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im)))
(.f64 (neg.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (.f64 im (.f64 im im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 im (-.f64 im (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))))))))
(.f64 (neg.f64 (.f64 (fma.f64 im (.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im) (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) im))))
(.f64 (-.f64 (.f64 im im) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))))) (/.f64 #s(literal 1 binary64) (-.f64 im (.f64 (.f64 im (.f64 im im)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))))
(+.f64 #s(literal -1/6 binary64) (.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))
(+.f64 (.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))
(-.f64 (/.f64 (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (/.f64 #s(literal 1/36 binary64) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))))
(-.f64 (/.f64 #s(literal 1/36 binary64) (-.f64 #s(literal -1/6 binary64) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) (/.f64 (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) (-.f64 #s(literal -1/6 binary64) (.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))))
(fma.f64 im (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) #s(literal -1/6 binary64))
(fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))
(fma.f64 (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) (.f64 im im) #s(literal -1/6 binary64))
(fma.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) im #s(literal -1/6 binary64))
(fma.f64 (.f64 (.f64 im im) (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (.f64 im im) #s(literal -1/604800 binary64)))) #s(literal -1/6 binary64))
(fma.f64 (.f64 (.f64 im im) (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))) #s(literal -1/6 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1/36 binary64) (-.f64 (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) (.f64 (.f64 im im) (.f64 (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))) (fma.f64 (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) #s(literal -1/216 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal -1/6 binary64) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) (-.f64 #s(literal 1/36 binary64) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))))))
(/.f64 (fma.f64 (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) #s(literal -1/216 binary64)) (-.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal 1/36 binary64)) (.f64 (.f64 im im) (.f64 (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))))
(/.f64 (fma.f64 (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) #s(literal -1/216 binary64)) (+.f64 #s(literal 1/36 binary64) (-.f64 (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) (.f64 (.f64 im im) (.f64 (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))))
(/.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal -1/36 binary64)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64)))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) #s(literal -1/216 binary64))) (neg.f64 (-.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal 1/36 binary64)) (.f64 (.f64 im im) (.f64 (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) #s(literal -1/216 binary64))) (neg.f64 (+.f64 #s(literal 1/36 binary64) (-.f64 (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) (.f64 (.f64 im im) (.f64 (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))))))
(/.f64 (neg.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal -1/36 binary64))) (neg.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))))
(/.f64 (-.f64 #s(literal 1/36 binary64) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))))) (-.f64 #s(literal -1/6 binary64) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))))
(/.f64 (-.f64 (.f64 (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64)) #s(literal 1/36 binary64))) (.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64)) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) #s(literal -1/216 binary64)))) (neg.f64 (neg.f64 (-.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal 1/36 binary64)) (.f64 (.f64 im im) (.f64 (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal -1/36 binary64)))) (neg.f64 (neg.f64 (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 1/36 binary64) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))))) (neg.f64 (-.f64 #s(literal -1/6 binary64) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 1/36 binary64) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (/.f64 (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (fma.f64 (/.f64 #s(literal 1/36 binary64) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (/.f64 #s(literal 1/36 binary64) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (.f64 (/.f64 (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))) (/.f64 #s(literal 1/36 binary64) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))) #s(literal -1 binary64))
(.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))
(.f64 (fma.f64 (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) #s(literal -1/216 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal 1/36 binary64)) (.f64 (.f64 im im) (.f64 (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64))))))
(.f64 (fma.f64 (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) #s(literal -1/216 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1/36 binary64) (-.f64 (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) (.f64 (.f64 im im) (.f64 (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))))))
(.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal -1/36 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64))))
(.f64 (neg.f64 (fma.f64 (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))) #s(literal -1/216 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal 1/36 binary64)) (.f64 (.f64 im im) (.f64 (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal -1/6 binary64)))))))
(.f64 (neg.f64 (fma.f64 (.f64 im im) (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))) #s(literal -1/36 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) #s(literal 1/6 binary64)))))
(.f64 (-.f64 #s(literal 1/36 binary64) (.f64 im (.f64 (.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) (.f64 (.f64 im im) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal -1/6 binary64) (.f64 (.f64 im im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))))
(sin.f64 im)
#s(approx (+ (* re 1/6) 1/2) #s(literal 1/2 binary64))
#s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64))
(exp.f64 (*.f64 (log.f64 im) #s(literal 3 binary64)))
(pow.f64 im #s(literal 3 binary64))
(pow.f64 (*.f64 im im) #s(literal 3/2 binary64))
(pow.f64 (pow.f64 im #s(literal 3/2 binary64)) #s(literal 2 binary64))
(pow.f64 (exp.f64 (log.f64 im)) #s(literal 3 binary64))
(.f64 im (.f64 im im))
(.f64 (.f64 im im) im)
(*.f64 (pow.f64 im #s(literal 3/2 binary64)) (pow.f64 im #s(literal 3/2 binary64)))
(+.f64 (.f64 im #s(literal 1/120 binary64)) (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))))
(+.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im #s(literal 1/120 binary64)))
(-.f64 (/.f64 (.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64))))) (-.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im #s(literal 1/120 binary64)))) (/.f64 (.f64 (.f64 im #s(literal 1/120 binary64)) (.f64 im #s(literal 1/120 binary64))) (-.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im #s(literal 1/120 binary64)))))
(fma.f64 im #s(literal 1/120 binary64) (.f64 im (.f64 im (*.f64 im #s(literal -1/5040 binary64)))))
(fma.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64))) (*.f64 im #s(literal 1/120 binary64)))
(fma.f64 #s(literal 1/120 binary64) im (.f64 im (.f64 im (*.f64 im #s(literal -1/5040 binary64)))))
(fma.f64 (.f64 im im) (.f64 im #s(literal -1/5040 binary64)) (*.f64 im #s(literal 1/120 binary64)))
(fma.f64 (.f64 im (.f64 im im)) #s(literal -1/5040 binary64) (*.f64 im #s(literal 1/120 binary64)))
(fma.f64 #s(literal -1/5040 binary64) (.f64 im (.f64 im im)) (*.f64 im #s(literal 1/120 binary64)))
(fma.f64 (.f64 im (.f64 im #s(literal -1/5040 binary64))) im (*.f64 im #s(literal 1/120 binary64)))
(fma.f64 (.f64 im #s(literal -1/5040 binary64)) (.f64 im im) (*.f64 im #s(literal 1/120 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (-.f64 (.f64 (.f64 im #s(literal 1/120 binary64)) (.f64 im #s(literal 1/120 binary64))) (.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im #s(literal 1/120 binary64))))) (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64))) (.f64 (.f64 im (*.f64 im im)) #s(literal 1/1728000 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im #s(literal 1/120 binary64))) (-.f64 (.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64))))) (.f64 (.f64 im #s(literal 1/120 binary64)) (.f64 im #s(literal 1/120 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (.f64 im im) #s(literal -1/604800 binary64))) (.f64 im (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (*.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64)) (.f64 im (fma.f64 (.f64 (.f64 im im) (*.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (.f64 im im) #s(literal -1/604800 binary64))) (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (*.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64)) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64)) (.f64 (fma.f64 (.f64 (.f64 im im) (*.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64)) im)))
(/.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64))) (.f64 (.f64 im (.f64 im im)) #s(literal 1/1728000 binary64))) (fma.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (-.f64 (.f64 (.f64 im #s(literal 1/120 binary64)) (.f64 im #s(literal 1/120 binary64))) (.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (*.f64 im #s(literal 1/120 binary64))))))
(/.f64 (-.f64 (.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64))))) (.f64 (.f64 im #s(literal 1/120 binary64)) (.f64 im #s(literal 1/120 binary64)))) (-.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im #s(literal 1/120 binary64))))
(/.f64 (.f64 im (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64))) (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (*.f64 im im) #s(literal -1/604800 binary64))))
(/.f64 (.f64 im (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64))) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64)))
(/.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64)) im) (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (*.f64 im im) #s(literal -1/604800 binary64))))
(/.f64 (.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64)) im) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64)))
(/.f64 (neg.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64))) (.f64 (.f64 im (.f64 im im)) #s(literal 1/1728000 binary64)))) (neg.f64 (fma.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (-.f64 (.f64 (.f64 im #s(literal 1/120 binary64)) (.f64 im #s(literal 1/120 binary64))) (.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (*.f64 im #s(literal 1/120 binary64)))))))
(/.f64 (neg.f64 (-.f64 (.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64))))) (.f64 (.f64 im #s(literal 1/120 binary64)) (.f64 im #s(literal 1/120 binary64))))) (neg.f64 (-.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im #s(literal 1/120 binary64)))))
(/.f64 (neg.f64 (.f64 im (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64)))) (neg.f64 (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (*.f64 im im) #s(literal -1/604800 binary64)))))
(/.f64 (neg.f64 (.f64 im (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64)))) (neg.f64 (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64)) im)) (neg.f64 (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (*.f64 im im) #s(literal -1/604800 binary64)))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64)) im)) (neg.f64 (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))))
(/.f64 (fma.f64 (.f64 im (.f64 im im)) #s(literal 1/1728000 binary64) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64))))) (fma.f64 (.f64 im #s(literal 1/120 binary64)) (.f64 im #s(literal 1/120 binary64)) (-.f64 (.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64))))) (.f64 (.f64 im #s(literal 1/120 binary64)) (.f64 im (.f64 im (*.f64 im #s(literal -1/5040 binary64))))))))
(.f64 im (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))
(.f64 (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)) im)
(.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64))) (.f64 (.f64 im (.f64 im im)) #s(literal 1/1728000 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (-.f64 (.f64 (.f64 im #s(literal 1/120 binary64)) (.f64 im #s(literal 1/120 binary64))) (.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im #s(literal 1/120 binary64)))))))
(.f64 (-.f64 (.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64))))) (.f64 (.f64 im #s(literal 1/120 binary64)) (.f64 im #s(literal 1/120 binary64)))) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 im (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (*.f64 im #s(literal 1/120 binary64)))))
(.f64 (.f64 im (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (.f64 im im) #s(literal -1/604800 binary64)))))
(.f64 (.f64 im (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))))
(.f64 (.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64)) im) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (.f64 im im) #s(literal -1/604800 binary64)))))
(.f64 (.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64)) im) (/.f64 #s(literal 1 binary64) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))))
(+.f64 #s(literal 1/120 binary64) (.f64 im (.f64 im #s(literal -1/5040 binary64))))
(+.f64 (.f64 im (.f64 im #s(literal -1/5040 binary64))) #s(literal 1/120 binary64))
(-.f64 (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64)) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))) (/.f64 #s(literal 1/14400 binary64) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))))
(-.f64 (/.f64 #s(literal 1/14400 binary64) (-.f64 #s(literal 1/120 binary64) (.f64 im (.f64 im #s(literal -1/5040 binary64))))) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64)) (-.f64 #s(literal 1/120 binary64) (.f64 im (.f64 im #s(literal -1/5040 binary64))))))
(fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))
(fma.f64 (*.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))
(fma.f64 #s(literal -1/5040 binary64) (*.f64 im im) #s(literal 1/120 binary64))
(fma.f64 (*.f64 im #s(literal -1/5040 binary64)) im #s(literal 1/120 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 #s(literal 1/14400 binary64) (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64)) (.f64 (.f64 im im) #s(literal -1/604800 binary64)))) (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (*.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(literal 1/120 binary64) (.f64 im (.f64 im #s(literal -1/5040 binary64)))) (-.f64 #s(literal 1/14400 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64)))))
(/.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64)) (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (.f64 im im) #s(literal -1/604800 binary64))))
(/.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64)) (+.f64 #s(literal 1/14400 binary64) (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64)) (.f64 (*.f64 im im) #s(literal -1/604800 binary64)))))
(/.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64)) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64)))
(/.f64 (neg.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64))) (neg.f64 (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (.f64 im im) #s(literal -1/604800 binary64)))))
(/.f64 (neg.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64))) (neg.f64 (+.f64 #s(literal 1/14400 binary64) (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64)) (.f64 (*.f64 im im) #s(literal -1/604800 binary64))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64))) (neg.f64 (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))))
(/.f64 (-.f64 #s(literal 1/14400 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64))) (-.f64 #s(literal 1/120 binary64) (.f64 im (.f64 im #s(literal -1/5040 binary64)))))
(/.f64 (-.f64 (.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64)) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))) (.f64 (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64)) #s(literal 1/14400 binary64))) (.f64 (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64)) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64)))) (neg.f64 (neg.f64 (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (.f64 im im) #s(literal -1/604800 binary64))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64)))) (neg.f64 (neg.f64 (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64)))))
(/.f64 (neg.f64 (-.f64 #s(literal 1/14400 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64)))) (neg.f64 (-.f64 #s(literal 1/120 binary64) (.f64 im (.f64 im #s(literal -1/5040 binary64))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64)) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 #s(literal 1/14400 binary64) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64)) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64)) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))) (fma.f64 (/.f64 #s(literal 1/14400 binary64) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))) (/.f64 #s(literal 1/14400 binary64) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))) (.f64 (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64)) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))) (/.f64 #s(literal 1/14400 binary64) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64)))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64))) #s(literal -1 binary64))
(.f64 #s(literal 1 binary64) (fma.f64 im (.f64 im #s(literal -1/5040 binary64)) #s(literal 1/120 binary64)))
(.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (*.f64 im im) #s(literal -1/604800 binary64)))))
(.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64)) (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1/14400 binary64) (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64)) (.f64 (.f64 im im) #s(literal -1/604800 binary64))))))
(.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64))))
(.f64 (neg.f64 (fma.f64 (.f64 im (.f64 im im)) (.f64 (.f64 im (.f64 im im)) #s(literal -1/128024064000 binary64)) #s(literal 1/1728000 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal 1/14400 binary64)) (.f64 (*.f64 im im) #s(literal -1/604800 binary64))))))
(.f64 (neg.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64) #s(literal -1/14400 binary64))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 im (*.f64 im #s(literal -1/5040 binary64)) #s(literal -1/120 binary64)))))
(.f64 (-.f64 #s(literal 1/14400 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/25401600 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1/120 binary64) (.f64 im (*.f64 im #s(literal -1/5040 binary64))))))

eval111.0ms (0.7%)

Memory: -21.2MiB live, 286.6MiB allocated
Compiler: Compiled 21 347 to 1 614 computations (92.4% saved)

prune107.0ms (0.7%)

Memory

10.5MiB live, 301.7MiB allocated

Pruning

35 alts after pruning (25 fresh and 10 done)

	Pruned	Kept	Total
New	896	10	906
Fresh	3	15	18
Picked	1	4	5
Done	0	6	6
Total	900	35	935

Accuracy

100.0%

Counts

935 → 35

Alt Table

Click to see full alt table

Status	Accuracy	Program
	39.6%	(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
✓	69.1%	(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))
	39.3%	(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
	60.5%	(.f64 #s(approx (exp re) (/.f64 #s(approx (+ ( re re) -1) #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (sin.f64 im))
✓	69.1%	(.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im))
✓	54.7%	(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
	30.3%	(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im #s(literal 1/120 binary64)) im #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
	29.8%	(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) (.f64 (.f64 im im) #s(literal 1/120 binary64))) (.f64 im (.f64 im im)) im)))
✓	33.7%	(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
	29.9%	(.f64 #s(approx (exp re) (.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (.f64 re #s(literal -1 binary64))))) #s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
✓	64.8%	#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
	29.1%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 (.f64 (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal -1 binary64)) re) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64)))))
	27.2%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)) (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (*.f64 re #s(literal 1/12 binary64)))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
	38.7%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal -1/4 binary64)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
✓	38.3%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
	38.7%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))))
	29.0%	#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
	15.9%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))))))
	14.7%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (.f64 re re) (*.f64 re (+.f64 #s(literal 1/6 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64)) re))))))))
	15.9%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
	15.5%	#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
✓	26.5%	#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
✓	53.9%	#s(approx (* (exp re) (sin im)) (sin.f64 im))
	37.3%	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
	34.0%	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))
✓	29.0%	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
	14.4%	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (/.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (.f64 re im)))))))
	14.4%	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (*.f64 re im))))))))
	22.9%	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re im) im)))))
	6.3%	#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
✓	33.8%	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
	29.6%	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im #s(approx (+ ( (* im im) -1/5040) 1/120) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
	33.4%	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
	23.6%	#s(approx (* (exp re) (sin im)) #s(approx (sin im) (/.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im)) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im))))
	19.3%	#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))

Compiler

Compiled 1 371 to 480 computations (65% saved)

regimes71.0ms (0.4%)

Memory

14.3MiB live, 171.3MiB allocated

Counts

48 → 1

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im #s(approx (+ ( (* im im) -1/5040) 1/120) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) (.f64 (.f64 im im) #s(literal 1/120 binary64))) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im #s(literal 1/120 binary64)) im #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re im) im)))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal -1/4 binary64)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (.f64 re re) (*.f64 re (+.f64 #s(literal 1/6 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64)) re))))))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)) (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (*.f64 re #s(literal 1/12 binary64)))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (/.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im)) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 (.f64 (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal -1 binary64)) re) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (.f64 re #s(literal -1 binary64))))) #s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (/.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (.f64 re im)))))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (*.f64 re im))))))))
#s(approx (* (exp re) (sin im)) (sin.f64 im))
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))
(.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im))
(.f64 #s(approx (exp re) (/.f64 #s(approx (+ ( re re) -1) #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (sin.f64 im))
(.f64 (exp.f64 re) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(*.f64 #s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (sin.f64 im))
(*.f64 (exp.f64 re) (sin.f64 im))

Outputs
(*.f64 (exp.f64 re) (sin.f64 im))

Calls

5 calls:

16.0ms	(sin.f64 im)
14.0ms	im
13.0ms	re
13.0ms	(*.f64 (exp.f64 re) (sin.f64 im))
12.0ms	(exp.f64 re)

Results

Accuracy	Segments	Branch
100.0%	1	`re`
100.0%	1	`im`
100.0%	1	`(*.f64 (exp.f64 re) (sin.f64 im))`
100.0%	1	`(exp.f64 re)`
100.0%	1	`(sin.f64 im)`

Compiler

Compiled 21 to 15 computations (28.6% saved)

regimes70.0ms (0.4%)

Memory

-12.8MiB live, 184.4MiB allocated

Counts

47 → 5

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im #s(approx (+ ( (* im im) -1/5040) 1/120) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) (.f64 (.f64 im im) #s(literal 1/120 binary64))) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im #s(literal 1/120 binary64)) im #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re im) im)))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal -1/4 binary64)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (.f64 re re) (*.f64 re (+.f64 #s(literal 1/6 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64)) re))))))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)) (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (*.f64 re #s(literal 1/12 binary64)))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (/.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im)) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 (.f64 (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal -1 binary64)) re) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (.f64 re #s(literal -1 binary64))))) #s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (/.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (.f64 re im)))))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (*.f64 re im))))))))
#s(approx (* (exp re) (sin im)) (sin.f64 im))
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))
(.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im))
(.f64 #s(approx (exp re) (/.f64 #s(approx (+ ( re re) -1) #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (sin.f64 im))
(.f64 (exp.f64 re) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(*.f64 #s(approx (exp re) (/.f64 (fma.f64 re re #s(literal -1 binary64)) (+.f64 re #s(literal -1 binary64)))) (sin.f64 im))

Outputs
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
(.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im))
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))

Calls

5 calls:

15.0ms	(sin.f64 im)
14.0ms	im
14.0ms	re
13.0ms	(*.f64 (exp.f64 re) (sin.f64 im))
10.0ms	(exp.f64 re)

Results

Accuracy	Segments	Branch
97.6%	4	`re`
84.8%	2	`im`
100.0%	5	`(*.f64 (exp.f64 re) (sin.f64 im))`
95.7%	3	`(exp.f64 re)`
84.9%	3	`(sin.f64 im)`

Compiler

Compiled 21 to 15 computations (28.6% saved)

regimes17.0ms (0.1%)

Memory

-3.4MiB live, 41.9MiB allocated

Counts

43 → 5

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im #s(approx (+ ( (* im im) -1/5040) 1/120) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) (.f64 (.f64 im im) #s(literal 1/120 binary64))) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im #s(literal 1/120 binary64)) im #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re im) im)))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal -1/4 binary64)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (.f64 re re) (*.f64 re (+.f64 #s(literal 1/6 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64)) re))))))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)) (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (*.f64 re #s(literal 1/12 binary64)))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (/.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im)) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 (.f64 (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal -1 binary64)) re) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (.f64 re #s(literal -1 binary64))))) #s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (/.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (.f64 re im)))))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (*.f64 re im))))))))
#s(approx (* (exp re) (sin im)) (sin.f64 im))
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))

Outputs
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im))
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))

Calls

1 calls:

15.0ms

(*.f64 (exp.f64 re) (sin.f64 im))

Results

Accuracy	Segments	Branch
100.0%	5	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 7 to 5 computations (28.6% saved)

regimes14.0ms (0.1%)

Memory

-3.5MiB live, 35.4MiB allocated

Counts

42 → 5

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im #s(approx (+ ( (* im im) -1/5040) 1/120) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) (.f64 (.f64 im im) #s(literal 1/120 binary64))) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im #s(literal 1/120 binary64)) im #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re im) im)))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal -1/4 binary64)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (.f64 re re) (*.f64 re (+.f64 #s(literal 1/6 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64)) re))))))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)) (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (*.f64 re #s(literal 1/12 binary64)))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (/.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im)) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 (.f64 (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal -1 binary64)) re) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (.f64 re #s(literal -1 binary64))))) #s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (/.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (.f64 re im)))))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (*.f64 re im))))))))
#s(approx (* (exp re) (sin im)) (sin.f64 im))
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))

Outputs
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
(*.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im))
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))

Calls

1 calls:

11.0ms

(*.f64 (exp.f64 re) (sin.f64 im))

Results

Accuracy	Segments	Branch
99.9%	5	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 7 to 5 computations (28.6% saved)

regimes14.0ms (0.1%)

Memory

-1.0MiB live, 38.0MiB allocated

Counts

41 → 5

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im #s(approx (+ ( (* im im) -1/5040) 1/120) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) (.f64 (.f64 im im) #s(literal 1/120 binary64))) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im #s(literal 1/120 binary64)) im #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re im) im)))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal -1/4 binary64)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (.f64 re re) (*.f64 re (+.f64 #s(literal 1/6 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64)) re))))))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)) (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (*.f64 re #s(literal 1/12 binary64)))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (/.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im)) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 (.f64 (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal -1 binary64)) re) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (.f64 re #s(literal -1 binary64))))) #s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (/.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (.f64 re im)))))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (*.f64 re im))))))))
#s(approx (* (exp re) (sin im)) (sin.f64 im))
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))

Outputs
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (sin.f64 im))
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))
#s(approx (* (exp re) (sin im)) (sin.f64 im))
#s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))

Calls

1 calls:

11.0ms

(*.f64 (exp.f64 re) (sin.f64 im))

Results

Accuracy	Segments	Branch
99.4%	5	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 7 to 5 computations (28.6% saved)

regimes59.0ms (0.4%)

Memory

-4.2MiB live, 154.7MiB allocated

Counts

40 → 5

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im #s(approx (+ ( (* im im) -1/5040) 1/120) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) (.f64 (.f64 im im) #s(literal 1/120 binary64))) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im #s(literal 1/120 binary64)) im #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re im) im)))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal -1/4 binary64)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (.f64 re re) (*.f64 re (+.f64 #s(literal 1/6 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64)) re))))))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)) (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (*.f64 re #s(literal 1/12 binary64)))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (/.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im)) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 (.f64 (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal -1 binary64)) re) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (.f64 re #s(literal -1 binary64))))) #s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (/.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (.f64 re im)))))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (*.f64 re im))))))))
#s(approx (* (exp re) (sin im)) (sin.f64 im))

Outputs
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (sin.f64 im))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) (sin.f64 im))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))

Calls

5 calls:

13.0ms	re
12.0ms	im
12.0ms	(sin.f64 im)
11.0ms	(*.f64 (exp.f64 re) (sin.f64 im))
9.0ms	(exp.f64 re)

Results

Accuracy	Segments	Branch
65.1%	4	`(sin.f64 im)`
65.1%	3	`im`
76.4%	3	`(exp.f64 re)`
76.5%	3	`re`
83.8%	5	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 21 to 15 computations (28.6% saved)

regimes60.0ms (0.4%)

Memory

-3.0MiB live, 154.4MiB allocated

Counts

39 → 2

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im #s(approx (+ ( (* im im) -1/5040) 1/120) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) (.f64 (.f64 im im) #s(literal 1/120 binary64))) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im #s(literal 1/120 binary64)) im #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re im) im)))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal -1/4 binary64)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (.f64 re re) (*.f64 re (+.f64 #s(literal 1/6 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64)) re))))))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 (.f64 re (.f64 re re)) #s(literal 1/216 binary64) #s(literal 1/8 binary64)) (-.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal 1/4 binary64)) (*.f64 re #s(literal 1/12 binary64)))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (/.f64 (-.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 im im) #s(literal 1/36 binary64))) (.f64 im im)) (-.f64 (.f64 #s(literal -1/6 binary64) (.f64 im (.f64 im im))) im))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 (.f64 (fma.f64 (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) #s(literal -1 binary64)) re) (/.f64 #s(literal 1 binary64) (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal -1 binary64))) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (.f64 (/.f64 (fma.f64 re re #s(literal -1 binary64)) (fma.f64 re (.f64 re re) #s(literal -1 binary64))) (-.f64 (fma.f64 re re #s(literal 1 binary64)) (.f64 re #s(literal -1 binary64))))) #s(approx (sin im) (fma.f64 #s(approx (+ (* (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (/.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (.f64 re im)))))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (fma.f64 im (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 im im)) (.f64 im (-.f64 im (*.f64 re im))))))))

Outputs

#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (*.f64 im (*.f64 #s(literal -1/6 binary64) (*.f64 im im))))))

(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (*.f64 im (*.f64 im im)) im)))

Calls

5 calls:

13.0ms	(sin.f64 im)
12.0ms	im
11.0ms	re
11.0ms	(*.f64 (exp.f64 re) (sin.f64 im))
10.0ms	(exp.f64 re)

Results

Accuracy	Segments	Branch
49.0%	2	`(sin.f64 im)`
46.3%	3	`im`
49.6%	2	`(exp.f64 re)`
49.6%	2	`re`
57.1%	2	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 21 to 15 computations (28.6% saved)

regimes10.0ms (0.1%)

Memory

32.5MiB live, 32.5MiB allocated

Counts

32 → 2

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im #s(approx (+ ( (* im im) -1/5040) 1/120) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) (.f64 (.f64 im im) #s(literal 1/120 binary64))) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im #s(literal 1/120 binary64)) im #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re im) im)))))
(.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (/.f64 (fma.f64 #s(literal 1/36 binary64) (.f64 re re) #s(literal -1/4 binary64)) (fma.f64 re #s(literal 1/6 binary64) #s(literal -1/2 binary64))) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (.f64 re re) (*.f64 re (+.f64 #s(literal 1/6 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 1/2 binary64)) re))))))))

Outputs

#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (*.f64 im (*.f64 #s(literal -1/6 binary64) (*.f64 im im))))))

(*.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (*.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (*.f64 im (*.f64 im im)) im)))

Calls

1 calls:

8.0ms

(*.f64 (exp.f64 re) (sin.f64 im))

Results

Accuracy	Segments	Branch
56.6%	2	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 7 to 5 computations (28.6% saved)

regimes11.0ms (0.1%)

Memory

-8.3MiB live, 30.4MiB allocated

Counts

29 → 2

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im #s(approx (+ ( (* im im) -1/5040) 1/120) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) (.f64 (.f64 im im) #s(literal 1/120 binary64))) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im #s(literal 1/120 binary64)) im #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im (fma.f64 (.f64 im im) #s(literal -1/5040 binary64) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (.f64 (.f64 (fma.f64 re im im) (-.f64 (.f64 re im) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re im) im)))))

Outputs

#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (*.f64 im (*.f64 #s(literal -1/6 binary64) (*.f64 im im))))))

#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re))))

Calls

1 calls:

8.0ms

(*.f64 (exp.f64 re) (sin.f64 im))

Results

Accuracy	Segments	Branch
56.1%	2	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 7 to 5 computations (28.6% saved)

regimes11.0ms (0.1%)

Memory

-17.1MiB live, 24.9MiB allocated

Counts

23 → 2

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im)) im)))
(.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 #s(approx (+ ( (* im im) 1/120) -1/6) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 im (.f64 im #s(approx (+ ( (* im im) -1/5040) 1/120) #s(literal 1/120 binary64))) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im)))

Outputs

#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (*.f64 im (*.f64 #s(literal -1/6 binary64) (*.f64 im im))))))

#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))

Calls

1 calls:

10.0ms

(*.f64 (exp.f64 re) (sin.f64 im))

Results

Accuracy	Segments	Branch
56.1%	2	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 7 to 5 computations (28.6% saved)

regimes6.0ms (0%)

Memory

22.4MiB live, 22.4MiB allocated

Counts

18 → 2

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))

Outputs

#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (*.f64 im (*.f64 #s(literal -1/6 binary64) (*.f64 im im))))))

#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im)))

Calls

1 calls:

5.0ms

(*.f64 (exp.f64 re) (sin.f64 im))

Results

Accuracy	Segments	Branch
55.7%	2	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 7 to 5 computations (28.6% saved)

regimes8.0ms (0%)

Memory

-18.3MiB live, 20.6MiB allocated

Counts

16 → 2

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(approx (+ ( re 1/6) 1/2) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (*.f64 re #s(literal 1/6 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 re (.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (.f64 (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) (.f64 re re))))))
#s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(approx (+ ( re (+ (* re (+ (* re 1/6) 1/2)) 1)) 1) (fma.f64 (*.f64 re re) (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) re)))))

Outputs

#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (*.f64 im (*.f64 #s(literal -1/6 binary64) (*.f64 im im))))))

#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))))

Calls

1 calls:

7.0ms

(*.f64 (exp.f64 re) (sin.f64 im))

Results

Accuracy	Segments	Branch
55.6%	2	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 7 to 5 computations (28.6% saved)

regimes4.0ms (0%)

Memory

14.5MiB live, 14.5MiB allocated

Counts

10 → 2

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im)))

Outputs

#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (*.f64 im (*.f64 #s(literal -1/6 binary64) (*.f64 im im))))))

#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im)))

Calls

1 calls:

3.0ms

(*.f64 (exp.f64 re) (sin.f64 im))

Results

Accuracy	Segments	Branch
51.2%	2	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 7 to 5 computations (28.6% saved)

regimes15.0ms (0.1%)

Memory

-0.7MiB live, 38.3MiB allocated

Counts

8 → 2

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (*.f64 im im))))))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im)))
#s(approx (* (exp re) (sin im)) #s(approx (sin im) (fma.f64 (.f64 im (.f64 im im)) #s(literal -1/6 binary64) im)))

Outputs

#s(approx (* (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (*.f64 im (*.f64 #s(literal -1/6 binary64) (*.f64 im im))))))

#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))

Calls

4 calls:

5.0ms	(*.f64 (exp.f64 re) (sin.f64 im))
3.0ms	re
3.0ms	(sin.f64 im)
2.0ms	(exp.f64 re)

Results

Accuracy	Segments	Branch
39.0%	2	`(sin.f64 im)`
42.9%	2	`(exp.f64 re)`
42.9%	2	`re`
46.2%	2	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 18 to 13 computations (27.8% saved)

regimes14.0ms (0.1%)

Memory

-3.1MiB live, 35.6MiB allocated

Counts

5 → 1

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re im im)))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))))

Outputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))

Calls

5 calls:

5.0ms	im
2.0ms	re
2.0ms	(sin.f64 im)
2.0ms	(*.f64 (exp.f64 re) (sin.f64 im))
2.0ms	(exp.f64 re)

Results

Accuracy	Segments	Branch
29.0%	1	`(sin.f64 im)`
29.0%	1	`(exp.f64 re)`
29.0%	1	`re`
29.0%	1	`im`
29.0%	1	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 21 to 15 computations (28.6% saved)

regimes12.0ms (0.1%)

Memory

-26.0MiB live, 21.7MiB allocated

Counts

2 → 2

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))

Outputs
#s(approx (* (exp re) (sin im)) (*.f64 im #s(approx (exp re) #s(literal 1 binary64))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))

Calls

5 calls:

5.0ms	re
2.0ms	(sin.f64 im)
2.0ms	im
1.0ms	(*.f64 (exp.f64 re) (sin.f64 im))
1.0ms	(exp.f64 re)

Results

Accuracy	Segments	Branch
29.2%	2	`(exp.f64 re)`
29.2%	2	`re`
28.9%	2	`(sin.f64 im)`
29.4%	2	`im`
29.3%	2	`(*.f64 (exp.f64 re) (sin.f64 im))`

Compiler

Compiled 21 to 15 computations (28.6% saved)

regimes7.0ms (0%)

Memory

19.7MiB live, 19.8MiB allocated

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

1 → 1

Calls

Call 1

Inputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))

Outputs
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))

Calls

5 calls:

1.0ms	(sin.f64 im)
1.0ms	im
1.0ms	re
1.0ms	(*.f64 (exp.f64 re) (sin.f64 im))
1.0ms	(exp.f64 re)

Results

Accuracy	Segments	Branch
6.3%	1	`(sin.f64 im)`
6.3%	1	`(exp.f64 re)`
6.3%	1	`re`
6.3%	1	`(*.f64 (exp.f64 re) (sin.f64 im))`
6.3%	1	`im`

Compiler

Compiled 21 to 15 computations (28.6% saved)

bsearch1.0ms (0%)

Memory

1.4MiB live, 1.4MiB allocated

Algorithm

4×	left-value

Steps

Time	Left	Right
0.0ms	0.9997287285916115	+inf
0.0ms	3.60485570312112e-21	2.0743356234050062e-20
0.0ms	-0.03733295214441016	0.0
0.0ms	-inf	-0.9994414444726764

Compiler

Compiled 10 to 10 computations (0% saved)

bsearch1.0ms (0%)

Memory

1.2MiB live, 1.2MiB allocated

Algorithm

4×	left-value

Steps

Time	Left	Right
0.0ms	0.9997287285916115	+inf
0.0ms	3.60485570312112e-21	2.0743356234050062e-20
0.0ms	-0.03733295214441016	0.0
0.0ms	-inf	-0.9994414444726764

Compiler

Compiled 10 to 10 computations (0% saved)

bsearch0.0ms (0%)

Memory

1.2MiB live, 1.2MiB allocated

Algorithm

4×	left-value

Steps

Time	Left	Right
0.0ms	0.9997287285916115	+inf
0.0ms	3.60485570312112e-21	2.0743356234050062e-20
0.0ms	-0.03733295214441016	0.0
0.0ms	-inf	-0.9994414444726764

Compiler

Compiled 10 to 10 computations (0% saved)

bsearch0.0ms (0%)

Memory

1.3MiB live, 1.3MiB allocated

Algorithm

4×	left-value

Steps

Time	Left	Right
0.0ms	0.9997287285916115	+inf
0.0ms	3.60485570312112e-21	2.0743356234050062e-20
0.0ms	-0.03733295214441016	0.0
0.0ms	-inf	-0.9994414444726764

Compiler

Compiled 10 to 10 computations (0% saved)

bsearch0.0ms (0%)

Memory

1.3MiB live, 1.3MiB allocated

Algorithm

4×	left-value

Steps

Time	Left	Right
0.0ms	0.9997287285916115	+inf
0.0ms	-0.0	1.0810173935238494e-282
0.0ms	-0.03733295214441016	0.0
0.0ms	-inf	-0.9994414444726764

Compiler

Compiled 10 to 10 computations (0% saved)

bsearch0.0ms (0%)

Memory

0.5MiB live, 0.5MiB allocated

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.0	1.0810173935238494e-282

Compiler

Compiled 10 to 10 computations (0% saved)

bsearch0.0ms (0%)

Memory

0.5MiB live, 0.5MiB allocated

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.0	1.0810173935238494e-282

Compiler

Compiled 10 to 10 computations (0% saved)

bsearch0.0ms (0%)

Memory

0.6MiB live, 0.6MiB allocated

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.0	1.0810173935238494e-282

Compiler

Compiled 10 to 10 computations (0% saved)

bsearch0.0ms (0%)

Memory

0.4MiB live, 0.4MiB allocated

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.0	1.0810173935238494e-282

Compiler

Compiled 10 to 10 computations (0% saved)

bsearch0.0ms (0%)

Memory

0.3MiB live, 0.3MiB allocated

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.0	1.0810173935238494e-282

Compiler

Compiled 10 to 10 computations (0% saved)

bsearch0.0ms (0%)

Memory

0.4MiB live, 0.4MiB allocated

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.0	1.0810173935238494e-282

Compiler

Compiled 10 to 10 computations (0% saved)

bsearch0.0ms (0%)

Memory

0.3MiB live, 0.3MiB allocated

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.0	1.0810173935238494e-282

Compiler

Compiled 10 to 10 computations (0% saved)

bsearch0.0ms (0%)

Memory

0.3MiB live, 0.3MiB allocated

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.0	1.0810173935238494e-282

Compiler

Compiled 10 to 10 computations (0% saved)

bsearch13.0ms (0.1%)

Memory

-14.3MiB live, 25.0MiB allocated

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
12.0ms	2.4155160465580587e+39	1.4636039651101807e+40

Samples

7.0ms

96×

valid

Compiler

Compiled 112 to 64 computations (42.9% saved)

Precisions

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

ival-sin: 3.0ms (61.6% of total)

ival-exp: 1.0ms (20.5% of total)

ival-mult: 1.0ms (20.5% of total)

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

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

simplify13.0ms (0.1%)

Memory

-11.7MiB live, 28.0MiB allocated

Algorithm

1×	egg-herbie

Rules

40×	`*-commutative_binary64`
8×	`+-commutative_binary64`
2×	`1-exp_binary64`
2×	`1-exp_binary32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	124	1006
1	150	1006

Stop Event

1×

saturated

Calls

Call 1

Inputs
(*.f64 (exp.f64 re) (sin.f64 im))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 6646139978924579/1329227995784915872903807060280344576 binary64)) #s(approx ( (exp re) (sin im)) (.f64 im (exp.f64 re))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) (.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im)) #s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 6646139978924579/1329227995784915872903807060280344576 binary64)) #s(approx ( (exp re) (sin im)) (.f64 im (exp.f64 re))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) (.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im)) #s(approx ( (exp re) (sin im)) (*.f64 im (exp.f64 re)))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 6646139978924579/1329227995784915872903807060280344576 binary64)) #s(approx ( (exp re) (sin im)) (.f64 im (exp.f64 re))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im)) #s(approx ( (exp re) (sin im)) (*.f64 im (exp.f64 re)))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) #s(approx ( (exp re) (sin im)) (sin.f64 im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 6646139978924579/1329227995784915872903807060280344576 binary64)) #s(approx ( (exp re) (sin im)) (.f64 im (exp.f64 re))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) #s(approx (* (exp re) (sin im)) (sin.f64 im)) #s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) #s(approx ( (exp re) (sin im)) (sin.f64 im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) #s(approx (* (exp re) (sin im)) (sin.f64 im)) (.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) (.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) (.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re)))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
(if (<=.f64 im #s(literal 2449999999999999935401107708933543297024 binary64)) #s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(literal 1 binary64)))) #s(approx ( (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))

Outputs
(*.f64 (exp.f64 re) (sin.f64 im))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 6646139978924579/1329227995784915872903807060280344576 binary64)) #s(approx ( (exp re) (sin im)) (.f64 im (exp.f64 re))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) (.f64 #s(approx (exp re) (+.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) re)) (sin.f64 im)) #s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) (.f64 (sin.f64 im) #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 6646139978924579/1329227995784915872903807060280344576 binary64)) #s(approx ( (exp re) (sin im)) (.f64 (exp.f64 re) im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) (.f64 (sin.f64 im) #s(approx (exp re) (+.f64 re (fma.f64 re (.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64))))) #s(approx (* (exp re) (sin im)) (*.f64 (exp.f64 re) im))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 6646139978924579/1329227995784915872903807060280344576 binary64)) #s(approx ( (exp re) (sin im)) (.f64 im (exp.f64 re))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) (.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) (sin.f64 im)) #s(approx ( (exp re) (sin im)) (*.f64 im (exp.f64 re)))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) (.f64 (sin.f64 im) #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 6646139978924579/1329227995784915872903807060280344576 binary64)) #s(approx ( (exp re) (sin im)) (.f64 (exp.f64 re) im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) (.f64 (sin.f64 im) #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64)))) #s(approx ( (exp re) (sin im)) (*.f64 (exp.f64 re) im))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 6646139978924579/1329227995784915872903807060280344576 binary64)) #s(approx ( (exp re) (sin im)) (.f64 im (exp.f64 re))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) (sin.f64 im)) #s(approx ( (exp re) (sin im)) (*.f64 im (exp.f64 re)))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) (.f64 (sin.f64 im) #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 6646139978924579/1329227995784915872903807060280344576 binary64)) #s(approx ( (exp re) (sin im)) (.f64 (exp.f64 re) im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) (.f64 (sin.f64 im) #s(approx (exp re) (+.f64 re #s(literal 1 binary64)))) #s(approx ( (exp re) (sin im)) (*.f64 (exp.f64 re) im))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) #s(approx ( (exp re) (sin im)) (sin.f64 im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 6646139978924579/1329227995784915872903807060280344576 binary64)) #s(approx ( (exp re) (sin im)) (.f64 im (exp.f64 re))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) #s(approx (* (exp re) (sin im)) (sin.f64 im)) #s(approx (* (exp re) (sin im)) (*.f64 im (exp.f64 re)))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) #s(approx ( (exp re) (sin im)) (sin.f64 im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 6646139978924579/1329227995784915872903807060280344576 binary64)) #s(approx ( (exp re) (sin im)) (.f64 (exp.f64 re) im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) #s(approx (* (exp re) (sin im)) (sin.f64 im)) #s(approx (* (exp re) (sin im)) (*.f64 (exp.f64 re) im))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -inf.0 binary64)) (.f64 #s(approx (exp re) (+.f64 re #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)) im))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal -5764607523034235/288230376151711744 binary64)) #s(approx ( (exp re) (sin im)) (sin.f64 im)) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) (if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 1 binary64)) #s(approx (* (exp re) (sin im)) (sin.f64 im)) (.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (.f64 im im)) im)))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) (.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) (.f64 #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))) #s(approx (sin im) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal -1/6 binary64)) (.f64 im (*.f64 im im)) im))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))) re)))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) (.f64 im #s(approx (exp re) (+.f64 re (+.f64 #s(literal 1 binary64) (.f64 re (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))))))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 im (*.f64 re (fma.f64 re #s(literal 1/6 binary64) #s(literal 1/2 binary64))) im) im))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) (*.f64 im #s(approx (exp re) (fma.f64 re (fma.f64 re #s(literal 1/2 binary64) #s(literal 1 binary64)) #s(literal 1 binary64))))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 #s(literal 1/2 binary64) im) im) im))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 re (fma.f64 re (*.f64 im #s(literal 1/2 binary64)) im) im))))
(if (<=.f64 (.f64 (exp.f64 re) (sin.f64 im)) #s(literal 0 binary64)) #s(approx ( (exp re) (sin im)) #s(approx (sin im) #s(approx (+ (* im (* -1/6 (* im im))) im) (.f64 im (.f64 #s(literal -1/6 binary64) (.f64 im im)))))) #s(approx ( (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) (fma.f64 im re im)))
(if (<=.f64 im #s(literal 2449999999999999935401107708933543297024 binary64)) #s(approx (* (exp re) (sin im)) (.f64 im #s(approx (exp re) #s(literal 1 binary64)))) #s(approx ( (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im)))))
#s(approx (* (exp re) (sin im)) #s(approx (* im (exp re)) #s(approx (+ (* re im) im) (*.f64 re im))))

soundness1.9s (11.6%)

Memory

26.4MiB live, 1 386.7MiB allocated

Rules

19 234×	`lower-fma.f64`
19 234×	`lower-fma.f32`
17 002×	`lower-fma.f64`
17 002×	`lower-fma.f32`
15 566×	`lower-fma.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	25	116
0	42	116
1	112	113
2	638	113
3	6255	113
0	8081	110
0	71	297
1	221	286
2	586	274
3	1574	268
4	2436	268
5	3110	268
6	3581	268
7	3732	268
8	4021	268
9	5977	268
0	8264	246
0	37	226
0	63	220
1	214	217
2	1462	217
0	8583	214
0	177	2469
1	544	2390
2	1543	2354
3	4661	2318
0	8109	2129
0	135	2161
1	427	2066
2	1198	2024
3	4225	1994
4	7847	1994
0	8069	1822
0	106	1649
1	328	1560
2	859	1528
3	2724	1498
4	5687	1498
5	7319	1498
0	8141	1378

Stop Event

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

Compiler

Compiled 1 162 to 432 computations (62.8% saved)

preprocess152.0ms (0.9%)

Memory: 2.1MiB live, 273.6MiB allocated
Compiler: Compiled 1 658 to 306 computations (81.5% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

Iter	Nodes	Cost
0	15	31
1	38	29
2	77	27
3	148	27
4	281	27
5	428	27
6	451	27
7	465	27
8	472	27
9	472	27
0	5	5
0	8	5
1	9	5
0	9	5

Iter	Nodes	Cost
0	25	138
0	42	138
1	67	138
2	94	135
3	123	135
4	134	135
5	137	135
6	164	135
7	164	135
8	176	135
9	176	135
10	188	135
11	188	135
0	188	132

Iter	Nodes	Cost
0	37	273
0	63	265
1	114	262
2	185	262
3	322	262
4	472	262
5	521	262
6	597	262
7	597	262
0	597	256

Iter	Nodes	Cost
0	15	31
1	38	29
2	77	27
3	148	27
4	281	27
5	428	27
6	451	27
7	465	27
8	472	27
9	472	27
0	5	5
0	8	5
1	9	5
0	9	5

Iter	Nodes	Cost
0	25	138
0	42	138
1	67	138
2	94	135
3	123	135
4	134	135
5	137	135
6	164	135
7	164	135
8	176	135
9	176	135
10	188	135
11	188	135
0	188	132

Iter	Nodes	Cost
0	37	273
0	63	265
1	114	262
2	185	262
3	322	262
4	472	262
5	521	262
6	597	262
7	597	262
0	597	256

start0.0ms (0%)

analyze0.0ms (0%)

sample971.0ms (6%)

explain68.0ms (0.4%)

preprocess26.0ms (0.2%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify3.0ms (0%)

localize28.0ms (0.2%)

series3.0ms (0%)

simplify396.0ms (2.4%)

rewrite16.0ms (0.1%)

eval5.0ms (0%)

prune17.0ms (0.1%)

simplify13.0ms (0.1%)

localize142.0ms (0.9%)

series30.0ms (0.2%)

simplify388.0ms (2.4%)

rewrite330.0ms (2%)

eval78.0ms (0.5%)

prune67.0ms (0.4%)

simplify31.0ms (0.2%)

localize126.0ms (0.8%)

series37.0ms (0.2%)

simplify1.0s (6.2%)

rewrite678.0ms (4.2%)

eval196.0ms (1.2%)

prune200.0ms (1.2%)

simplify533.0ms (3.3%)

localize278.0ms (1.7%)

series10.0ms (0.1%)

simplify7.6s (46.6%)

rewrite328.0ms (2%)

eval111.0ms (0.7%)

prune107.0ms (0.7%)

regimes71.0ms (0.4%)

regimes70.0ms (0.4%)

regimes17.0ms (0.1%)

regimes14.0ms (0.1%)

regimes14.0ms (0.1%)

regimes59.0ms (0.4%)

regimes60.0ms (0.4%)

regimes10.0ms (0.1%)

regimes11.0ms (0.1%)

regimes11.0ms (0.1%)

regimes6.0ms (0%)

regimes8.0ms (0%)

regimes4.0ms (0%)

regimes15.0ms (0.1%)

regimes14.0ms (0.1%)

regimes12.0ms (0.1%)

regimes7.0ms (0%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch13.0ms (0.1%)

simplify13.0ms (0.1%)

soundness1.9s (11.6%)

preprocess152.0ms (0.9%)

end0.0ms (0%)

Profiling

Iter	Nodes	Cost
0	15	31
1	38	29
2	77	27
3	148	27
4	281	27
5	428	27
6	451	27
7	465	27
8	472	27
9	472	27
0	5	5
0	8	5
1	9	5
0	9	5

Iter	Nodes	Cost
0	25	138
0	42	138
1	67	138
2	94	135
3	123	135
4	134	135
5	137	135
6	164	135
7	164	135
8	176	135
9	176	135
10	188	135
11	188	135
0	188	132

Iter	Nodes	Cost
0	37	273
0	63	265
1	114	262
2	185	262
3	322	262
4	472	262
5	521	262
6	597	262
7	597	262
0	597	256