Metrics for math.sin on complex, real part

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated; 0ms collecting garbage

analyze0.0ms (0%)

Memory

0.5MiB live, 0.5MiB allocated; 0ms collecting garbage

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 14 to 13 computations (7.1% saved)

sample1.2s (16.5%)

Memory

24.4MiB live, 1 486.3MiB allocated; 199ms collecting garbage

Samples

863.0ms

8 256×

valid

Precisions

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

ival-sin: 234.0ms (37.3% of total)

ival-mult: 160.0ms (25.5% of total)

ival-exp: 113.0ms (18% of total)

ival-add: 55.0ms (8.8% of total)

ival-sub: 46.0ms (7.3% of total)

exact: 9.0ms (1.4% of total)

ival-true: 5.0ms (0.8% of total)

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

adjust: 2.0ms (0.3% of total)

Bogosity

explain140.0ms (2%)

Memory

-20.8MiB live, 130.9MiB allocated; 13ms collecting garbage

FPErrors

Click to see full error table

Example	Example	Subexpression
-	-	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`
-	-	`(exp.f64 im)`
-	-	`(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))`
-	-	`(sin.f64 re)`
-	-	`#s(literal 0 binary64)`
-	-	`im`
-	-	`(-.f64 #s(literal 0 binary64) im)`
-	-	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
-	-	`re`
-	-	`#s(literal 1/2 binary64)`
-	-	`(exp.f64 (-.f64 #s(literal 0 binary64) 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

48.0ms

512×

valid

Compiler

Compiled 92 to 37 computations (59.8% saved)

Precisions

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

ival-sin: 11.0ms (34.3% of total)

ival-exp: 9.0ms (28.1% of total)

ival-mult: 6.0ms (18.7% of total)

ival-add: 2.0ms (6.2% of total)

ival-sub: 2.0ms (6.2% of total)

exact: 1.0ms (3.1% of total)

adjust: 0.0ms (0% of total)

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

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

preprocess308.0ms (4.4%)

Memory

1.9MiB live, 184.1MiB allocated; 34ms collecting garbage

Iterations

Useful iterations: 4 (0.0ms)

Iter	Nodes	Cost
0	29	61
1	103	55
2	435	55
3	1642	55
0	11	12
0	18	11
1	38	11
2	116	11
3	522	11
4	2799	5
0	8602	5

Stop Event

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

Calls

Call 1

Inputs
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

Outputs
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))
(*.f64 (cosh.f64 im) (sin.f64 re))

Symmetry

(abs im)

(negabs re)

Compiler

Compiled 12 to 11 computations (8.3% saved)

eval0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated; 0ms collecting garbage
Compiler: Compiled 0 to 2 computations (-∞% saved)

prune1.0ms (0%)

Memory

1.2MiB live, 1.2MiB allocated; 0ms collecting garbage

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	100.0%	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

Compiler

Compiled 12 to 11 computations (8.3% saved)

simplify207.0ms (2.9%)

Memory

43.9MiB live, 190.5MiB allocated; 22ms collecting garbage

Localize:

Found 4 expressions of interest:

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

Iterations

Useful iterations: 4 (0.0ms)

Iter	Nodes	Cost
0	11	38
0	18	34
1	38	34
2	116	34
3	522	34
4	2799	28
0	8602	28

Stop Event

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

Calls

Call 1

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

Outputs
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))
(*.f64 (cosh.f64 im) (sin.f64 re))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
#s(literal 1/2 binary64)
(sin.f64 re)
re
(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))
(+.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(exp.f64 (-.f64 #s(literal 0 binary64) im))
(exp.f64 (neg.f64 im))
(-.f64 #s(literal 0 binary64) im)
(neg.f64 im)
#s(literal 0 binary64)
im
(exp.f64 im)

localize32.0ms (0.4%)

Memory

-0.8MiB live, 46.8MiB allocated; 2ms collecting garbage

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0.0	(exp.f64 (-.f64 #s(literal 0 binary64) im))
accuracy	0.0	(exp.f64 im)
accuracy	0.00390625	(sin.f64 re)
accuracy	0.0078125	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

Samples

23.0ms

256×

valid

Compiler

Compiled 40 to 13 computations (67.5% saved)

Precisions

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

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

ival-exp: 3.0ms (20.1% of total)

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

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

ival-sub: 1.0ms (6.7% of total)

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

series33.0ms (0.5%)

Memory

-35.3MiB live, 10.9MiB allocated; 7ms collecting garbage

Counts

6 → 30

Calls

Call 1

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

Outputs
(* 1/2 (* re (+ (exp im) (exp (neg im)))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* 1/240 (* (pow re 2) (+ (exp im) (exp (neg im)))))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/240 (+ (exp im) (exp (neg im))))))))))
(* 1/2 re)
(* re (+ 1/2 (* -1/12 (pow re 2))))
(* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))
(* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))
re
(* re (+ 1 (* -1/6 (pow re 2))))
(* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))
(* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))
(* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))
(* 1/2 (sin re))
(sin re)
(+ (sin re) (* 1/2 (* (pow im 2) (sin re))))
(+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))
(* -1 im)
1
(+ 1 im)
(+ 1 (* im (+ 1 (* 1/2 im))))
(+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))
(+ 1 (* -1 im))
(+ 1 (* im (- (* 1/2 im) 1)))
(+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))
(exp im)
(exp (neg im))
(* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))
(exp (* -1 im))

Calls

6 calls:

Time	Variable		Point	Expression
26.0ms	re	@	inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (- 0 im) (* 1/2 (sin re)) (sin re) (exp im) (exp (- 0 im)))
1.0ms	im	@	inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (- 0 im) (* 1/2 (sin re)) (sin re) (exp im) (exp (- 0 im)))
1.0ms	im	@	0	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (- 0 im) (* 1/2 (sin re)) (sin re) (exp im) (exp (- 0 im)))
1.0ms	im	@	-inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (- 0 im) (* 1/2 (sin re)) (sin re) (exp im) (exp (- 0 im)))
1.0ms	re	@	0	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (- 0 im) (* 1/2 (sin re)) (sin re) (exp im) (exp (- 0 im)))

simplify196.0ms (2.8%)

Memory

16.7MiB live, 173.2MiB allocated; 57ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	118	362
1	455	330
2	1902	319
0	8251	289

Stop Event

1×	iter limit
1×	node limit

Counts

30 → 29

Calls

Call 1

Inputs
(* 1/2 (* re (+ (exp im) (exp (neg im)))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* 1/240 (* (pow re 2) (+ (exp im) (exp (neg im)))))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/240 (+ (exp im) (exp (neg im))))))))))
(* 1/2 re)
(* re (+ 1/2 (* -1/12 (pow re 2))))
(* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))
(* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))
re
(* re (+ 1 (* -1/6 (pow re 2))))
(* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))
(* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))
(* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))
(* 1/2 (sin re))
(sin re)
(+ (sin re) (* 1/2 (* (pow im 2) (sin re))))
(+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))
(* -1 im)
1
(+ 1 im)
(+ 1 (* im (+ 1 (* 1/2 im))))
(+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))
(+ 1 (* -1 im))
(+ 1 (* im (- (* 1/2 im) 1)))
(+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))
(exp im)
(exp (neg im))
(* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))
(exp (* -1 im))

Outputs
(* 1/2 (* re (+ (exp im) (exp (neg im)))))
(.f64 (.f64 #s(literal 1/2 binary64) re) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))
(.f64 (fma.f64 (exp.f64 im) re (/.f64 re (exp.f64 im))) (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* 1/240 (* (pow re 2) (+ (exp im) (exp (neg im)))))))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (.f64 (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) (.f64 (.f64 #s(literal 1/2 binary64) re) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/240 (+ (exp im) (exp (neg im))))))))))
(.f64 (fma.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (fma.f64 #s(literal -1/10080 binary64) (.f64 re re) #s(literal 1/240 binary64)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) (.f64 (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* re (+ 1/2 (* -1/12 (pow re 2))))
(.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)
(* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))
(.f64 (fma.f64 (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64)) (*.f64 re re) #s(literal 1/2 binary64)) re)
(* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (fma.f64 (pow.f64 re #s(literal 4 binary64)) #s(literal -1/10080 binary64) (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64))) (.f64 #s(literal 1/2 binary64) re))
re
(* re (+ 1 (* -1/6 (pow re 2))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64) re)
(* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (-.f64 (.f64 #s(literal 1/120 binary64) (.f64 re re)) #s(literal 1/6 binary64)) re)
(* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (fma.f64 (pow.f64 re #s(literal 4 binary64)) #s(literal -1/5040 binary64) (-.f64 (.f64 #s(literal 1/120 binary64) (.f64 re re)) #s(literal 1/6 binary64))) re)
(* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(* 1/2 (sin re))
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
(sin re)
(sin.f64 re)
(+ (sin re) (* 1/2 (* (pow im 2) (sin re))))
(.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))
(+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))
(fma.f64 (.f64 (fma.f64 #s(literal 1/24 binary64) (.f64 im im) #s(literal 1/2 binary64)) (sin.f64 re)) (*.f64 im im) (sin.f64 re))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))
(fma.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (fma.f64 #s(literal 1/720 binary64) (.f64 im im) #s(literal 1/24 binary64)) (sin.f64 re)) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re)))
(* -1 im)
(neg.f64 im)
1
#s(literal 1 binary64)
(+ 1 im)
(+.f64 #s(literal 1 binary64) im)
(+ 1 (* im (+ 1 (* 1/2 im))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 1 binary64)) im #s(literal 1 binary64))
(+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/6 binary64) im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) im #s(literal 1 binary64))
(+ 1 (* -1 im))
(-.f64 #s(literal 1 binary64) im)
(+ 1 (* im (- (* 1/2 im) 1)))
(fma.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) im) #s(literal 1 binary64)) im #s(literal 1 binary64))
(+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))
(fma.f64 (-.f64 (*.f64 (fma.f64 #s(literal -1/6 binary64) im #s(literal 1/2 binary64)) im) #s(literal 1 binary64)) im #s(literal 1 binary64))
(exp im)
(exp.f64 im)
(exp (neg im))
(exp.f64 (neg.f64 im))
(* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(exp (* -1 im))
(exp.f64 (neg.f64 im))

rewrite72.0ms (1%)

Memory

-18.2MiB live, 75.1MiB allocated; 6ms collecting garbage

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	11	27
0	18	24
1	64	22
0	484	22

Stop Event

1×	iter limit
1×	iter limit
1×	iter limit
1×	unsound
1×	iter limit

Counts

6 → 52

Calls

Call 1

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

Outputs
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re))
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im)))
(.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
(.f64 #s(literal 1/2 binary64) (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)))
(/.f64 (.f64 (-.f64 (exp.f64 (.f64 (neg.f64 im) #s(literal 2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64))) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (.f64 (neg.f64 im) #s(literal 2 binary64)))))
(/.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (-.f64 (exp.f64 (*.f64 (neg.f64 im) #s(literal 2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64)))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(/.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64))))) (fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (.f64 (neg.f64 im) #s(literal 2 binary64)))))
(/.f64 (-.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))) (-.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re))))
(/.f64 (+.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64))) (fma.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (-.f64 (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re))) (.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re))))))
(fma.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im)) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) (exp.f64 (neg.f64 im))) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1/2 binary64) (.f64 (sin.f64 re) (exp.f64 im)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1/2 binary64) (.f64 (sin.f64 re) (exp.f64 (neg.f64 im))) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(-.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (neg.f64 (exp.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(-.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (neg.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (exp.f64 im)))
(+.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(/.f64 (neg.f64 (*.f64 im (neg.f64 im))) (neg.f64 im))
(/.f64 (neg.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64)))) (*.f64 im (neg.f64 im)))
(/.f64 (*.f64 im (neg.f64 im)) im)
(/.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) (*.f64 im im))
(neg.f64 im)
(-.f64 (/.f64 #s(literal 0 binary64) im) (/.f64 (*.f64 im im) im))
(-.f64 (/.f64 #s(literal 0 binary64) (.f64 im im)) (/.f64 (pow.f64 im #s(literal 3 binary64)) (.f64 im im)))
(-.f64 #s(literal 0 binary64) im)
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
(sin.f64 re)
(/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im)))
(/.f64 (+.f64 (pow.f64 (cosh.f64 im) #s(literal 3 binary64)) (pow.f64 (sinh.f64 im) #s(literal 3 binary64))) (fma.f64 (cosh.f64 im) (cosh.f64 im) (-.f64 (.f64 (sinh.f64 im) (sinh.f64 im)) (.f64 (cosh.f64 im) (sinh.f64 im)))))
(exp.f64 im)
(+.f64 (sinh.f64 im) (cosh.f64 im))
(+.f64 (cosh.f64 im) (sinh.f64 im))
(/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 (neg.f64 im)) (sinh.f64 (neg.f64 im)))) (-.f64 (cosh.f64 im) (sinh.f64 (neg.f64 im))))
(/.f64 (+.f64 (pow.f64 (cosh.f64 im) #s(literal 3 binary64)) (pow.f64 (sinh.f64 (neg.f64 im)) #s(literal 3 binary64))) (fma.f64 (cosh.f64 im) (cosh.f64 im) (-.f64 (.f64 (sinh.f64 (neg.f64 im)) (sinh.f64 (neg.f64 im))) (.f64 (cosh.f64 im) (sinh.f64 (neg.f64 im))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (exp.f64 im)))
(/.f64 #s(literal 1 binary64) (exp.f64 im))
(-.f64 (cosh.f64 im) (sinh.f64 im))
(exp.f64 (neg.f64 im))
(+.f64 (sinh.f64 (neg.f64 im)) (cosh.f64 im))
(+.f64 (cosh.f64 im) (sinh.f64 (neg.f64 im)))

eval9.0ms (0.1%)

Memory: 15.0MiB live, 15.0MiB allocated; 0ms collecting garbage
Compiler: Compiled 1 562 to 311 computations (80.1% saved)

prune4.0ms (0.1%)

Memory

7.7MiB live, 7.7MiB allocated; 0ms collecting garbage

Pruning

4 alts after pruning (4 fresh and 0 done)

	Pruned	Kept	Total
New	75	4	79
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	76	4	80

Accuracy

100.0%

Counts

80 → 4

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	55.9%	(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (.f64 (neg.f64 im) #s(literal 2 binary64)))))
▶	100.0%	(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
▶	55.8%	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im)))))
▶	76.3%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re)))

Compiler

Compiled 86 to 65 computations (24.4% saved)

simplify217.0ms (3.1%)

Memory

0.3MiB live, 194.1MiB allocated; 19ms collecting garbage

Localize:

Found 16 expressions of interest:

New	Metric	Score
cost-diff	0	(.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
cost-diff	0	(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (.f64 (neg.f64 im) #s(literal 2 binary64)))))
cost-diff	1	(*.f64 (neg.f64 im) #s(literal 2 binary64))
cost-diff	1	(*.f64 (neg.f64 im) #s(literal 3 binary64))
cost-diff	0	(cosh.f64 im)
cost-diff	0	(*.f64 #s(literal 2 binary64) (cosh.f64 im))
cost-diff	0	(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re))
cost-diff	4	(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
cost-diff	2	(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im))))
cost-diff	3	(/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im)))
cost-diff	4	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im)))))
cost-diff	10	(-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im)))
cost-diff	0	(*.f64 #s(literal 1/2 binary64) im)
cost-diff	0	(fma.f64 (*.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64))
cost-diff	0	(.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))
cost-diff	0	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re)))

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	47	296
0	81	264
1	182	237
2	643	215
3	5971	215
0	8768	215

Stop Event

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

Calls

Call 1

Inputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re)))
(.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64))
(*.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
#s(literal 1 binary64)
(sin.f64 re)
re
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im)))))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
#s(literal 1/2 binary64)
(sin.f64 re)
re
(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im))))
(exp.f64 (-.f64 #s(literal 0 binary64) im))
(-.f64 #s(literal 0 binary64) im)
#s(literal 0 binary64)
im
(/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im)))
(-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im)))
(*.f64 (cosh.f64 im) (cosh.f64 im))
(cosh.f64 im)
(*.f64 (sinh.f64 im) (sinh.f64 im))
(sinh.f64 im)
(exp.f64 (neg.f64 im))
(neg.f64 im)
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re))
(*.f64 #s(literal 2 binary64) (cosh.f64 im))
#s(literal 2 binary64)
(cosh.f64 im)
im
(sin.f64 re)
re
#s(literal 1/2 binary64)
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (.f64 (neg.f64 im) #s(literal 2 binary64)))))
(.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (*.f64 (neg.f64 im) #s(literal 3 binary64))))
(pow.f64 (exp.f64 im) #s(literal 3 binary64))
(exp.f64 im)
im
#s(literal 3 binary64)
(exp.f64 (*.f64 (neg.f64 im) #s(literal 3 binary64)))
(*.f64 (neg.f64 im) #s(literal 3 binary64))
(neg.f64 im)
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
(sin.f64 re)
re
#s(literal 1/2 binary64)
(fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (*.f64 (neg.f64 im) #s(literal 2 binary64))))
(-.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(exp.f64 (neg.f64 im))
(exp.f64 (*.f64 (neg.f64 im) #s(literal 2 binary64)))
(*.f64 (neg.f64 im) #s(literal 2 binary64))
#s(literal 2 binary64)

Outputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (sin.f64 re) (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))))
(.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))
(.f64 (sin.f64 re) (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64))
(fma.f64 (*.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))
(*.f64 #s(literal 1/2 binary64) im)
(*.f64 im #s(literal 1/2 binary64))
#s(literal 1/2 binary64)
im
#s(literal 1 binary64)
(sin.f64 re)
re
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im)))))
(*.f64 (cosh.f64 im) (sin.f64 re))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
#s(literal 1/2 binary64)
(sin.f64 re)
re
(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im))))
(*.f64 #s(literal 2 binary64) (cosh.f64 im))
(exp.f64 (-.f64 #s(literal 0 binary64) im))
(exp.f64 (neg.f64 im))
(-.f64 #s(literal 0 binary64) im)
(neg.f64 im)
#s(literal 0 binary64)
im
(/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im)))
(exp.f64 im)
(-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im)))
#s(literal 1 binary64)
(*.f64 (cosh.f64 im) (cosh.f64 im))
(cosh.f64 im)
(*.f64 (sinh.f64 im) (sinh.f64 im))
(sinh.f64 im)
(exp.f64 (neg.f64 im))
(neg.f64 im)
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
(*.f64 (cosh.f64 im) (sin.f64 re))
(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re))
(.f64 (.f64 #s(literal 2 binary64) (sin.f64 re)) (cosh.f64 im))
(*.f64 #s(literal 2 binary64) (cosh.f64 im))
#s(literal 2 binary64)
(cosh.f64 im)
im
(sin.f64 re)
re
#s(literal 1/2 binary64)
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (.f64 (neg.f64 im) #s(literal 2 binary64)))))
(.f64 (/.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64))) (fma.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 im) (pow.f64 (exp.f64 im) #s(literal -2 binary64)))) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (*.f64 (neg.f64 im) #s(literal 3 binary64))))
(+.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64)))
(pow.f64 (exp.f64 im) #s(literal 3 binary64))
(exp.f64 im)
im
#s(literal 3 binary64)
(exp.f64 (*.f64 (neg.f64 im) #s(literal 3 binary64)))
(pow.f64 (exp.f64 im) #s(literal -3 binary64))
(*.f64 (neg.f64 im) #s(literal 3 binary64))
(*.f64 #s(literal -3 binary64) im)
(neg.f64 im)
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
(sin.f64 re)
re
#s(literal 1/2 binary64)
(fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (*.f64 (neg.f64 im) #s(literal 2 binary64))))
(fma.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 im) (pow.f64 (exp.f64 im) #s(literal -2 binary64)))
(-.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(exp.f64 (neg.f64 im))
(exp.f64 (*.f64 (neg.f64 im) #s(literal 2 binary64)))
(pow.f64 (exp.f64 im) #s(literal -2 binary64))
(*.f64 (neg.f64 im) #s(literal 2 binary64))
(*.f64 #s(literal -2 binary64) im)
#s(literal 2 binary64)

localize302.0ms (4.3%)

Memory

-16.6MiB live, 415.3MiB allocated; 50ms collecting garbage

Localize:

Found 16 expressions of interest:

New	Metric	Score
accuracy	0.0078125	(fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (*.f64 (neg.f64 im) #s(literal 2 binary64))))
accuracy	0.024101269536884032	(pow.f64 (exp.f64 im) #s(literal 3 binary64))
accuracy	0.2578104358302058	(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (.f64 (neg.f64 im) #s(literal 2 binary64)))))
accuracy	32.46636344408786	(-.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
accuracy	0.0	(*.f64 #s(literal 2 binary64) (cosh.f64 im))
accuracy	0.0	(cosh.f64 im)
accuracy	0.00390625	(sin.f64 re)
accuracy	0.0078125	(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re))
accuracy	0.0078125	(*.f64 (cosh.f64 im) (cosh.f64 im))
accuracy	0.01171875	(sinh.f64 im)
accuracy	0.01953125	(*.f64 (sinh.f64 im) (sinh.f64 im))
accuracy	0.2500027510508252	(-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im)))
accuracy	0.0	(*.f64 #s(literal 1/2 binary64) im)
accuracy	0.00390625	(sin.f64 re)
accuracy	0.0078125	(.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))
accuracy	0.645815830770955	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re)))

Samples

118.0ms	62×	2	valid
88.0ms	78×	1	valid
36.0ms	111×	0	exit
10.0ms	1×	5	exit
1.0ms	4×	0	valid

Compiler

Compiled 292 to 45 computations (84.6% saved)

Precisions

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

ival-exp: 44.0ms (25.9% of total)

ival-pow: 36.0ms (21.2% of total)

ival-mult: 29.0ms (17.1% of total)

adjust: 24.0ms (14.1% of total)

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

ival-cosh: 7.0ms (4.1% of total)

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

ival-div: 5.0ms (2.9% of total)

ival-sub: 5.0ms (2.9% of total)

ival-sinh: 4.0ms (2.4% of total)

exact: 1.0ms (0.6% of total)

ival-neg: 1.0ms (0.6% of total)

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

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

series65.0ms (0.9%)

Memory

2.9MiB live, 142.4MiB allocated; 16ms collecting garbage

Counts

23 → 110

Calls

Call 1

Inputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re)))
(.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64))
(*.f64 #s(literal 1/2 binary64) im)
(-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im)))
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im)))))
(/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im)))
(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im))))
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re))
(*.f64 #s(literal 2 binary64) (cosh.f64 im))
(cosh.f64 im)
(*.f64 (neg.f64 im) #s(literal 3 binary64))
(*.f64 (neg.f64 im) #s(literal 2 binary64))
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (.f64 (neg.f64 im) #s(literal 2 binary64)))))
(.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(sin.f64 re)
(*.f64 (sinh.f64 im) (sinh.f64 im))
(sinh.f64 im)
(*.f64 (cosh.f64 im) (cosh.f64 im))
(-.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(pow.f64 (exp.f64 im) #s(literal 3 binary64))
(fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (*.f64 (neg.f64 im) #s(literal 2 binary64))))

Outputs
(* 1/2 (* re (+ (exp im) (exp (neg im)))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* 1/240 (* (pow re 2) (+ (exp im) (exp (neg im)))))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/240 (+ (exp im) (exp (neg im))))))))))
(* re (+ 1 (* 1/2 (pow im 2))))
(* re (+ 1 (+ (* -1/6 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/2 (pow im 2)))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* 1/120 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))))))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/120 (+ 1 (* 1/2 (pow im 2)))))))))))
(* 1/2 (* re (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))
(* re (+ (* -1/12 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))) (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))))
(* re (+ (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* 1/240 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))))))
(* re (+ (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))) (* 1/240 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))))))))
(* 1/2 (* re (+ (exp im) (/ 1 (exp im)))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/2 (+ (exp im) (/ 1 (exp im))))))
(* re (+ (* 1/2 (+ (exp im) (/ 1 (exp im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (/ 1 (exp im)))) (* 1/240 (* (pow re 2) (+ (exp im) (/ 1 (exp im)))))))))
(* re (+ (* 1/2 (+ (exp im) (/ 1 (exp im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (/ 1 (exp im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/240 (+ (exp im) (/ 1 (exp im))))))))))
(* re (+ (exp im) (/ 1 (exp im))))
(* re (+ (exp im) (+ (* -1/6 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (/ 1 (exp im)))))
(* re (+ (exp im) (+ (* (pow re 2) (+ (* -1/6 (+ (exp im) (/ 1 (exp im)))) (* 1/120 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))))) (/ 1 (exp im)))))
(* re (+ (exp im) (+ (* (pow re 2) (+ (* -1/6 (+ (exp im) (/ 1 (exp im)))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/120 (+ (exp im) (/ 1 (exp im)))))))) (/ 1 (exp im)))))
(* 1/2 (/ (* re (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))
(* re (+ (* -1/12 (/ (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* 1/2 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))))
(* re (+ (* 1/2 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* (pow re 2) (+ (* -1/12 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* 1/240 (/ (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))))))
(* re (+ (* 1/2 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* (pow re 2) (+ (* -1/12 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* (pow re 2) (+ (* -1/10080 (/ (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* 1/240 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))))))))
(* 1/2 (* re (+ (exp (* -3 im)) (pow (exp im) 3))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3)))) (* 1/2 (+ (exp (* -3 im)) (pow (exp im) 3)))))
(* re (+ (* 1/2 (+ (exp (* -3 im)) (pow (exp im) 3))) (* (pow re 2) (+ (* -1/12 (+ (exp (* -3 im)) (pow (exp im) 3))) (* 1/240 (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3))))))))
(* re (+ (* 1/2 (+ (exp (* -3 im)) (pow (exp im) 3))) (* (pow re 2) (+ (* -1/12 (+ (exp (* -3 im)) (pow (exp im) 3))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3)))) (* 1/240 (+ (exp (* -3 im)) (pow (exp im) 3)))))))))
re
(* re (+ 1 (* -1/6 (pow re 2))))
(* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))
(* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))
(* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))
(* (sin re) (+ 1 (* 1/2 (pow im 2))))
(* 1/2 (* (sin re) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))
(* 1/2 (* (sin re) (+ (exp im) (/ 1 (exp im)))))
(* (sin re) (+ (exp im) (/ 1 (exp im))))
(* 1/2 (/ (* (sin re) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))
(* 1/2 (* (sin re) (+ (exp (* -3 im)) (pow (exp im) 3))))
(sin re)
(+ (sin re) (* 1/2 (* (pow im 2) (sin re))))
(+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))
1
(+ 1 (* 1/2 (pow im 2)))
(* 1/2 im)
(+ 1 im)
(+ 1 (* im (+ 1 (* 1/2 im))))
(+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))
2
(+ 2 (pow im 2))
(+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))
(+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))
(* 2 (sin re))
(+ (* 2 (sin re)) (* (pow im 2) (sin re)))
(+ (* 2 (sin re)) (* (pow im 2) (+ (sin re) (* 1/12 (* (pow im 2) (sin re))))))
(+ (* 2 (sin re)) (* (pow im 2) (+ (sin re) (* (pow im 2) (+ (* 1/360 (* (pow im 2) (sin re))) (* 1/12 (sin re)))))))
(+ 1 (* (pow im 2) (+ 1/2 (* 1/24 (pow im 2)))))
(+ 1 (* (pow im 2) (+ 1/2 (* (pow im 2) (+ 1/24 (* 1/720 (pow im 2)))))))
(* -3 im)
(* -2 im)
(+ (sin re) (* 1/2 (* (pow im 2) (- (* 9 (sin re)) (* 8 (sin re))))))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (* 27/4 (sin re)) (+ (* 8/3 (sin re)) (* 4 (- (* 9 (sin re)) (* 8 (sin re)))))))) (* 1/2 (- (* 9 (sin re)) (* 8 (sin re)))))))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (- (* 9 (sin re)) (* 8 (sin re)))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (* 81/40 (sin re)) (+ (* 16/45 (sin re)) (+ (* 4/3 (- (* 9 (sin re)) (* 8 (sin re)))) (* 4 (- (* 27/4 (sin re)) (+ (* 8/3 (sin re)) (* 4 (- (* 9 (sin re)) (* 8 (sin re)))))))))))) (* 1/2 (- (* 27/4 (sin re)) (+ (* 8/3 (sin re)) (* 4 (- (* 9 (sin re)) (* 8 (sin re))))))))))))
(+ (sin re) (* 9/2 (* (pow im 2) (sin re))))
(+ (sin re) (* (pow im 2) (+ (* 27/8 (* (pow im 2) (sin re))) (* 9/2 (sin re)))))
(+ (sin re) (* (pow im 2) (+ (* 9/2 (sin re)) (* (pow im 2) (+ (* 81/80 (* (pow im 2) (sin re))) (* 27/8 (sin re)))))))
(pow im 2)
(* (pow im 2) (+ 1 (* 1/3 (pow im 2))))
(* (pow im 2) (+ 1 (* (pow im 2) (+ 1/3 (* 2/45 (pow im 2))))))
(* (pow im 2) (+ 1 (* (pow im 2) (+ 1/3 (* (pow im 2) (+ 2/45 (* 1/315 (pow im 2))))))))
im
(* im (+ 1 (* 1/6 (pow im 2))))
(* im (+ 1 (* (pow im 2) (+ 1/6 (* 1/120 (pow im 2))))))
(* im (+ 1 (* (pow im 2) (+ 1/6 (* (pow im 2) (+ 1/120 (* 1/5040 (pow im 2))))))))
(+ 1 (pow im 2))
(+ 1 (* (pow im 2) (+ 1 (* 1/3 (pow im 2)))))
(+ 1 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/3 (* 2/45 (pow im 2)))))))
(* 2 im)
(* im (+ 2 (* 1/3 (pow im 2))))
(* im (+ 2 (* (pow im 2) (+ 1/3 (* 1/60 (pow im 2))))))
(* im (+ 2 (* (pow im 2) (+ 1/3 (* (pow im 2) (+ 1/60 (* 1/2520 (pow im 2))))))))
(+ 1 (* 3 im))
(+ 1 (* im (+ 3 (* 9/2 im))))
(+ 1 (* im (+ 3 (* im (+ 9/2 (* 9/2 im))))))
(+ 1 (* 4 (pow im 2)))
(+ 1 (* (pow im 2) (+ 4 (* 4/3 (pow im 2)))))
(+ 1 (* (pow im 2) (+ 4 (* (pow im 2) (+ 4/3 (* 8/45 (pow im 2)))))))
(* 1/2 (* (pow im 2) (sin re)))
(* (pow im 2) (+ (* 1/2 (sin re)) (/ (sin re) (pow im 2))))
(* 1/2 (pow im 2))
(* (pow im 2) (+ 1/2 (/ 1 (pow im 2))))
(- (* 1/4 (pow (+ (exp im) (/ 1 (exp im))) 2)) (* 1/4 (pow (- (exp im) (/ 1 (exp im))) 2)))
(/ (- (* 1/4 (pow (+ (exp im) (/ 1 (exp im))) 2)) (* 1/4 (pow (- (exp im) (/ 1 (exp im))) 2))) (exp (neg im)))
(- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))
(+ (exp im) (/ 1 (exp im)))
(* 1/2 (+ (exp im) (/ 1 (exp im))))
(* 1/4 (pow (- (exp im) (/ 1 (exp im))) 2))
(* 1/2 (- (exp im) (/ 1 (exp im))))
(* 1/4 (pow (+ (exp im) (/ 1 (exp im))) 2))
(- (exp im) (exp (neg im)))
(pow (exp im) 3)
(+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))
(* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))
(* 1/2 (* (sin re) (- (+ (exp (* -1 im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (* -1 im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (* -1 im)))))))
(/ (- (* 1/4 (pow (+ (exp im) (/ 1 (exp im))) 2)) (* 1/4 (pow (- (exp im) (/ 1 (exp im))) 2))) (exp (* -1 im)))
(- (+ (exp (* -1 im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (* -1 im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (* -1 im)))))
(* 1/2 (/ (* (sin re) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (* -1 im)))))))
(- (exp im) (exp (* -1 im)))
(+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (* -1 im)))))

Calls

6 calls:

Time	Variable		Point	Expression
15.0ms	re	@	inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* (* 1/2 im) im) 1) (* 1/2 im) (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))))) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (* (* (* 2 (cosh im)) (sin re)) 1/2) (* (* 2 (cosh im)) (sin re)) (* 2 (cosh im)) (cosh im) (* (neg im) 3) (* (neg im) 2) (/ (* (+ (pow (exp im) 3) (exp (* (neg im) 3))) (* (sin re) 1/2)) (+ (* (exp im) (- (exp im) (exp (neg im)))) (exp (* (neg im) 2)))) (* (+ (pow (exp im) 3) (exp (* (neg im) 3))) (* (sin re) 1/2)) (sin re) (* (sinh im) (sinh im)) (sinh im) (* (cosh im) (cosh im)) (- (exp im) (exp (neg im))) (pow (exp im) 3) (+ (* (exp im) (- (exp im) (exp (neg im)))) (exp (* (neg im) 2))))
13.0ms	im	@	0	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* (* 1/2 im) im) 1) (* 1/2 im) (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))))) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (* (* (* 2 (cosh im)) (sin re)) 1/2) (* (* 2 (cosh im)) (sin re)) (* 2 (cosh im)) (cosh im) (* (neg im) 3) (* (neg im) 2) (/ (* (+ (pow (exp im) 3) (exp (* (neg im) 3))) (* (sin re) 1/2)) (+ (* (exp im) (- (exp im) (exp (neg im)))) (exp (* (neg im) 2)))) (* (+ (pow (exp im) 3) (exp (* (neg im) 3))) (* (sin re) 1/2)) (sin re) (* (sinh im) (sinh im)) (sinh im) (* (cosh im) (cosh im)) (- (exp im) (exp (neg im))) (pow (exp im) 3) (+ (* (exp im) (- (exp im) (exp (neg im)))) (exp (* (neg im) 2))))
12.0ms	im	@	-inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* (* 1/2 im) im) 1) (* 1/2 im) (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))))) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (* (* (* 2 (cosh im)) (sin re)) 1/2) (* (* 2 (cosh im)) (sin re)) (* 2 (cosh im)) (cosh im) (* (neg im) 3) (* (neg im) 2) (/ (* (+ (pow (exp im) 3) (exp (* (neg im) 3))) (* (sin re) 1/2)) (+ (* (exp im) (- (exp im) (exp (neg im)))) (exp (* (neg im) 2)))) (* (+ (pow (exp im) 3) (exp (* (neg im) 3))) (* (sin re) 1/2)) (sin re) (* (sinh im) (sinh im)) (sinh im) (* (cosh im) (cosh im)) (- (exp im) (exp (neg im))) (pow (exp im) 3) (+ (* (exp im) (- (exp im) (exp (neg im)))) (exp (* (neg im) 2))))
10.0ms	im	@	inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* (* 1/2 im) im) 1) (* 1/2 im) (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))))) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (* (* (* 2 (cosh im)) (sin re)) 1/2) (* (* 2 (cosh im)) (sin re)) (* 2 (cosh im)) (cosh im) (* (neg im) 3) (* (neg im) 2) (/ (* (+ (pow (exp im) 3) (exp (* (neg im) 3))) (* (sin re) 1/2)) (+ (* (exp im) (- (exp im) (exp (neg im)))) (exp (* (neg im) 2)))) (* (+ (pow (exp im) 3) (exp (* (neg im) 3))) (* (sin re) 1/2)) (sin re) (* (sinh im) (sinh im)) (sinh im) (* (cosh im) (cosh im)) (- (exp im) (exp (neg im))) (pow (exp im) 3) (+ (* (exp im) (- (exp im) (exp (neg im)))) (exp (* (neg im) 2))))
6.0ms	re	@	0	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* (* 1/2 im) im) 1) (* 1/2 im) (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))))) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (* (* (* 2 (cosh im)) (sin re)) 1/2) (* (* 2 (cosh im)) (sin re)) (* 2 (cosh im)) (cosh im) (* (neg im) 3) (* (neg im) 2) (/ (* (+ (pow (exp im) 3) (exp (* (neg im) 3))) (* (sin re) 1/2)) (+ (* (exp im) (- (exp im) (exp (neg im)))) (exp (* (neg im) 2)))) (* (+ (pow (exp im) 3) (exp (* (neg im) 3))) (* (sin re) 1/2)) (sin re) (* (sinh im) (sinh im)) (sinh im) (* (cosh im) (cosh im)) (- (exp im) (exp (neg im))) (pow (exp im) 3) (+ (* (exp im) (- (exp im) (exp (neg im)))) (exp (* (neg im) 2))))

simplify143.0ms (2%)

Memory

-0.4MiB live, 240.2MiB allocated; 23ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	449	2379
1	1866	2008
0	8538	1851

Stop Event

1×	iter limit
1×	node limit

Counts

110 → 108

Calls

Call 1

Inputs
(* 1/2 (* re (+ (exp im) (exp (neg im)))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* 1/240 (* (pow re 2) (+ (exp im) (exp (neg im)))))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/240 (+ (exp im) (exp (neg im))))))))))
(* re (+ 1 (* 1/2 (pow im 2))))
(* re (+ 1 (+ (* -1/6 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/2 (pow im 2)))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* 1/120 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))))))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/120 (+ 1 (* 1/2 (pow im 2)))))))))))
(* 1/2 (* re (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))
(* re (+ (* -1/12 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))) (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))))
(* re (+ (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* 1/240 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))))))
(* re (+ (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))) (* 1/240 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))))))))
(* 1/2 (* re (+ (exp im) (/ 1 (exp im)))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/2 (+ (exp im) (/ 1 (exp im))))))
(* re (+ (* 1/2 (+ (exp im) (/ 1 (exp im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (/ 1 (exp im)))) (* 1/240 (* (pow re 2) (+ (exp im) (/ 1 (exp im)))))))))
(* re (+ (* 1/2 (+ (exp im) (/ 1 (exp im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (/ 1 (exp im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/240 (+ (exp im) (/ 1 (exp im))))))))))
(* re (+ (exp im) (/ 1 (exp im))))
(* re (+ (exp im) (+ (* -1/6 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (/ 1 (exp im)))))
(* re (+ (exp im) (+ (* (pow re 2) (+ (* -1/6 (+ (exp im) (/ 1 (exp im)))) (* 1/120 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))))) (/ 1 (exp im)))))
(* re (+ (exp im) (+ (* (pow re 2) (+ (* -1/6 (+ (exp im) (/ 1 (exp im)))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/120 (+ (exp im) (/ 1 (exp im)))))))) (/ 1 (exp im)))))
(* 1/2 (/ (* re (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))
(* re (+ (* -1/12 (/ (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* 1/2 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))))
(* re (+ (* 1/2 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* (pow re 2) (+ (* -1/12 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* 1/240 (/ (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))))))
(* re (+ (* 1/2 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* (pow re 2) (+ (* -1/12 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* (pow re 2) (+ (* -1/10080 (/ (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* 1/240 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))))))))
(* 1/2 (* re (+ (exp (* -3 im)) (pow (exp im) 3))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3)))) (* 1/2 (+ (exp (* -3 im)) (pow (exp im) 3)))))
(* re (+ (* 1/2 (+ (exp (* -3 im)) (pow (exp im) 3))) (* (pow re 2) (+ (* -1/12 (+ (exp (* -3 im)) (pow (exp im) 3))) (* 1/240 (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3))))))))
(* re (+ (* 1/2 (+ (exp (* -3 im)) (pow (exp im) 3))) (* (pow re 2) (+ (* -1/12 (+ (exp (* -3 im)) (pow (exp im) 3))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3)))) (* 1/240 (+ (exp (* -3 im)) (pow (exp im) 3)))))))))
re
(* re (+ 1 (* -1/6 (pow re 2))))
(* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))
(* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))
(* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))
(* (sin re) (+ 1 (* 1/2 (pow im 2))))
(* 1/2 (* (sin re) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))
(* 1/2 (* (sin re) (+ (exp im) (/ 1 (exp im)))))
(* (sin re) (+ (exp im) (/ 1 (exp im))))
(* 1/2 (/ (* (sin re) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))
(* 1/2 (* (sin re) (+ (exp (* -3 im)) (pow (exp im) 3))))
(sin re)
(+ (sin re) (* 1/2 (* (pow im 2) (sin re))))
(+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))
1
(+ 1 (* 1/2 (pow im 2)))
(* 1/2 im)
(+ 1 im)
(+ 1 (* im (+ 1 (* 1/2 im))))
(+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))
2
(+ 2 (pow im 2))
(+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))
(+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))
(* 2 (sin re))
(+ (* 2 (sin re)) (* (pow im 2) (sin re)))
(+ (* 2 (sin re)) (* (pow im 2) (+ (sin re) (* 1/12 (* (pow im 2) (sin re))))))
(+ (* 2 (sin re)) (* (pow im 2) (+ (sin re) (* (pow im 2) (+ (* 1/360 (* (pow im 2) (sin re))) (* 1/12 (sin re)))))))
(+ 1 (* (pow im 2) (+ 1/2 (* 1/24 (pow im 2)))))
(+ 1 (* (pow im 2) (+ 1/2 (* (pow im 2) (+ 1/24 (* 1/720 (pow im 2)))))))
(* -3 im)
(* -2 im)
(+ (sin re) (* 1/2 (* (pow im 2) (- (* 9 (sin re)) (* 8 (sin re))))))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (* 27/4 (sin re)) (+ (* 8/3 (sin re)) (* 4 (- (* 9 (sin re)) (* 8 (sin re)))))))) (* 1/2 (- (* 9 (sin re)) (* 8 (sin re)))))))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (- (* 9 (sin re)) (* 8 (sin re)))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (* 81/40 (sin re)) (+ (* 16/45 (sin re)) (+ (* 4/3 (- (* 9 (sin re)) (* 8 (sin re)))) (* 4 (- (* 27/4 (sin re)) (+ (* 8/3 (sin re)) (* 4 (- (* 9 (sin re)) (* 8 (sin re)))))))))))) (* 1/2 (- (* 27/4 (sin re)) (+ (* 8/3 (sin re)) (* 4 (- (* 9 (sin re)) (* 8 (sin re))))))))))))
(+ (sin re) (* 9/2 (* (pow im 2) (sin re))))
(+ (sin re) (* (pow im 2) (+ (* 27/8 (* (pow im 2) (sin re))) (* 9/2 (sin re)))))
(+ (sin re) (* (pow im 2) (+ (* 9/2 (sin re)) (* (pow im 2) (+ (* 81/80 (* (pow im 2) (sin re))) (* 27/8 (sin re)))))))
(pow im 2)
(* (pow im 2) (+ 1 (* 1/3 (pow im 2))))
(* (pow im 2) (+ 1 (* (pow im 2) (+ 1/3 (* 2/45 (pow im 2))))))
(* (pow im 2) (+ 1 (* (pow im 2) (+ 1/3 (* (pow im 2) (+ 2/45 (* 1/315 (pow im 2))))))))
im
(* im (+ 1 (* 1/6 (pow im 2))))
(* im (+ 1 (* (pow im 2) (+ 1/6 (* 1/120 (pow im 2))))))
(* im (+ 1 (* (pow im 2) (+ 1/6 (* (pow im 2) (+ 1/120 (* 1/5040 (pow im 2))))))))
(+ 1 (pow im 2))
(+ 1 (* (pow im 2) (+ 1 (* 1/3 (pow im 2)))))
(+ 1 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/3 (* 2/45 (pow im 2)))))))
(* 2 im)
(* im (+ 2 (* 1/3 (pow im 2))))
(* im (+ 2 (* (pow im 2) (+ 1/3 (* 1/60 (pow im 2))))))
(* im (+ 2 (* (pow im 2) (+ 1/3 (* (pow im 2) (+ 1/60 (* 1/2520 (pow im 2))))))))
(+ 1 (* 3 im))
(+ 1 (* im (+ 3 (* 9/2 im))))
(+ 1 (* im (+ 3 (* im (+ 9/2 (* 9/2 im))))))
(+ 1 (* 4 (pow im 2)))
(+ 1 (* (pow im 2) (+ 4 (* 4/3 (pow im 2)))))
(+ 1 (* (pow im 2) (+ 4 (* (pow im 2) (+ 4/3 (* 8/45 (pow im 2)))))))
(* 1/2 (* (pow im 2) (sin re)))
(* (pow im 2) (+ (* 1/2 (sin re)) (/ (sin re) (pow im 2))))
(* 1/2 (pow im 2))
(* (pow im 2) (+ 1/2 (/ 1 (pow im 2))))
(- (* 1/4 (pow (+ (exp im) (/ 1 (exp im))) 2)) (* 1/4 (pow (- (exp im) (/ 1 (exp im))) 2)))
(/ (- (* 1/4 (pow (+ (exp im) (/ 1 (exp im))) 2)) (* 1/4 (pow (- (exp im) (/ 1 (exp im))) 2))) (exp (neg im)))
(- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))
(+ (exp im) (/ 1 (exp im)))
(* 1/2 (+ (exp im) (/ 1 (exp im))))
(* 1/4 (pow (- (exp im) (/ 1 (exp im))) 2))
(* 1/2 (- (exp im) (/ 1 (exp im))))
(* 1/4 (pow (+ (exp im) (/ 1 (exp im))) 2))
(- (exp im) (exp (neg im)))
(pow (exp im) 3)
(+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))
(* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))
(* 1/2 (* (sin re) (- (+ (exp (* -1 im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (* -1 im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (* -1 im)))))))
(/ (- (* 1/4 (pow (+ (exp im) (/ 1 (exp im))) 2)) (* 1/4 (pow (- (exp im) (/ 1 (exp im))) 2))) (exp (* -1 im)))
(- (+ (exp (* -1 im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (* -1 im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (* -1 im)))))
(* 1/2 (/ (* (sin re) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (* -1 im)))))))
(- (exp im) (exp (* -1 im)))
(+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (* -1 im)))))

Outputs
(* 1/2 (* re (+ (exp im) (exp (neg im)))))
(.f64 (.f64 re #s(literal 1/2 binary64)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))
(.f64 (.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64))) re)
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* 1/240 (* (pow re 2) (+ (exp im) (exp (neg im)))))))))
(.f64 (fma.f64 (.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64))) (.f64 re re) (fma.f64 (exp.f64 im) #s(literal 1/2 binary64) (/.f64 #s(literal 1/2 binary64) (exp.f64 im)))) re)
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/240 (+ (exp im) (exp (neg im))))))))))
(.f64 (fma.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) (.f64 (.f64 (.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) (fma.f64 #s(literal -1/10080 binary64) (.f64 re re) #s(literal 1/240 binary64))) (.f64 re re)) (.f64 re re))) re)
(* re (+ 1 (* 1/2 (pow im 2))))
(.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)
(* re (+ 1 (+ (* -1/6 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/2 (pow im 2)))))
(.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* 1/120 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))))))))
(.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 #s(literal 1/120 binary64) (.f64 re re) #s(literal -1/6 binary64))) (.f64 re re) (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/120 (+ 1 (* 1/2 (pow im 2)))))))))))
(.f64 (fma.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 #s(literal -1/5040 binary64) (.f64 re re) #s(literal 1/120 binary64))) (.f64 re re) (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64))) (.f64 re re) (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(* 1/2 (* re (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))
(.f64 (.f64 re #s(literal 1/2 binary64)) (fma.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im))))
(* re (+ (* -1/12 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))) (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))))
(.f64 (.f64 (fma.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im))) (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64))) re)
(* re (+ (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* 1/240 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))))))
(.f64 (fma.f64 (.f64 (fma.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im))) (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64))) (.f64 re re) (*.f64 (fma.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im))) #s(literal 1/2 binary64))) re)
(* re (+ (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))) (* 1/240 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))))))))
(.f64 (fma.f64 (fma.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im))) (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (fma.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im))) (fma.f64 #s(literal -1/10080 binary64) (.f64 re re) #s(literal 1/240 binary64))))) re)
(* 1/2 (* re (+ (exp im) (/ 1 (exp im)))))
(.f64 (.f64 re #s(literal 1/2 binary64)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/2 (+ (exp im) (/ 1 (exp im))))))
(.f64 (.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64))) re)
(* re (+ (* 1/2 (+ (exp im) (/ 1 (exp im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (/ 1 (exp im)))) (* 1/240 (* (pow re 2) (+ (exp im) (/ 1 (exp im)))))))))
(.f64 (fma.f64 (.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64))) (.f64 re re) (fma.f64 (exp.f64 im) #s(literal 1/2 binary64) (/.f64 #s(literal 1/2 binary64) (exp.f64 im)))) re)
(* re (+ (* 1/2 (+ (exp im) (/ 1 (exp im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (/ 1 (exp im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/240 (+ (exp im) (/ 1 (exp im))))))))))
(.f64 (fma.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) (.f64 (.f64 (.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) (fma.f64 #s(literal -1/10080 binary64) (.f64 re re) #s(literal 1/240 binary64))) (.f64 re re)) (.f64 re re))) re)
(* re (+ (exp im) (/ 1 (exp im))))
(fma.f64 (exp.f64 im) re (/.f64 re (exp.f64 im)))
(* re (+ (exp im) (+ (* -1/6 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (/ 1 (exp im)))))
(.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) (*.f64 re re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) re)
(* re (+ (exp im) (+ (* (pow re 2) (+ (* -1/6 (+ (exp im) (/ 1 (exp im)))) (* 1/120 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))))) (/ 1 (exp im)))))
(.f64 (fma.f64 (.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) (fma.f64 #s(literal 1/120 binary64) (.f64 re re) #s(literal -1/6 binary64))) (.f64 re re) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) re)
(* re (+ (exp im) (+ (* (pow re 2) (+ (* -1/6 (+ (exp im) (/ 1 (exp im)))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/120 (+ (exp im) (/ 1 (exp im)))))))) (/ 1 (exp im)))))
(.f64 (fma.f64 (fma.f64 (.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) (fma.f64 #s(literal -1/5040 binary64) (.f64 re re) #s(literal 1/120 binary64))) (.f64 re re) (fma.f64 #s(literal -1/6 binary64) (exp.f64 im) (/.f64 #s(literal -1/6 binary64) (exp.f64 im)))) (*.f64 re re) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) re)
(* 1/2 (/ (* re (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))
(/.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64)))) (fma.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 im) (pow.f64 (exp.f64 im) #s(literal -2 binary64))))
(* re (+ (* -1/12 (/ (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* 1/2 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))))
(.f64 (/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64))) (fma.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 im) (pow.f64 (exp.f64 im) #s(literal -2 binary64)))) re)
(* re (+ (* 1/2 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* (pow re 2) (+ (* -1/12 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* 1/240 (/ (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))))))
(.f64 (fma.f64 (/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64))) (fma.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 im) (pow.f64 (exp.f64 im) #s(literal -2 binary64)))) (.f64 re re) (*.f64 (/.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (fma.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 im) (pow.f64 (exp.f64 im) #s(literal -2 binary64)))) #s(literal 1/2 binary64))) re)
(* re (+ (* 1/2 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* (pow re 2) (+ (* -1/12 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* (pow re 2) (+ (* -1/10080 (/ (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im))))))) (* 1/240 (/ (+ (exp (* -3 im)) (pow (exp im) 3)) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))))))))
(.f64 (+.f64 (/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64))) (fma.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 im) (pow.f64 (exp.f64 im) #s(literal -2 binary64)))) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (fma.f64 #s(literal -1/10080 binary64) (*.f64 re re) #s(literal 1/240 binary64))) (fma.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 im) (pow.f64 (exp.f64 im) #s(literal -2 binary64)))))) re)
(* 1/2 (* re (+ (exp (* -3 im)) (pow (exp im) 3))))
(.f64 (.f64 re #s(literal 1/2 binary64)) (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3)))) (* 1/2 (+ (exp (* -3 im)) (pow (exp im) 3)))))
(.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64))) re)
(* re (+ (* 1/2 (+ (exp (* -3 im)) (pow (exp im) 3))) (* (pow re 2) (+ (* -1/12 (+ (exp (* -3 im)) (pow (exp im) 3))) (* 1/240 (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3))))))))
(.f64 (fma.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64))) (.f64 re re) (*.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) #s(literal 1/2 binary64))) re)
(* re (+ (* 1/2 (+ (exp (* -3 im)) (pow (exp im) 3))) (* (pow re 2) (+ (* -1/12 (+ (exp (* -3 im)) (pow (exp im) 3))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp (* -3 im)) (pow (exp im) 3)))) (* 1/240 (+ (exp (* -3 im)) (pow (exp im) 3)))))))))
(.f64 (fma.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) (.f64 (.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (fma.f64 #s(literal -1/10080 binary64) (.f64 re re) #s(literal 1/240 binary64))) (.f64 re re)) (.f64 re re))) re)
re
(* re (+ 1 (* -1/6 (pow re 2))))
(.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re)
(* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))
(.f64 (fma.f64 (-.f64 (.f64 #s(literal 1/120 binary64) (.f64 re re)) #s(literal 1/6 binary64)) (.f64 re re) #s(literal 1 binary64)) re)
(* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))
(fma.f64 (.f64 re (.f64 re re)) (-.f64 (.f64 (.f64 (fma.f64 #s(literal -1/5040 binary64) (*.f64 re re) #s(literal 1/120 binary64)) re) re) #s(literal 1/6 binary64)) re)
(* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))
(*.f64 (fma.f64 (exp.f64 im) #s(literal 1/2 binary64) (/.f64 #s(literal 1/2 binary64) (exp.f64 im))) (sin.f64 re))
(* (sin re) (+ 1 (* 1/2 (pow im 2))))
(.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (sin.f64 re))
(* 1/2 (* (sin re) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))
(.f64 (.f64 (fma.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im))) (sin.f64 re)) #s(literal 1/2 binary64))
(* 1/2 (* (sin re) (+ (exp im) (/ 1 (exp im)))))
(*.f64 (fma.f64 (exp.f64 im) #s(literal 1/2 binary64) (/.f64 #s(literal 1/2 binary64) (exp.f64 im))) (sin.f64 re))
(* (sin re) (+ (exp im) (/ 1 (exp im))))
(*.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) (sin.f64 re))
(* 1/2 (/ (* (sin re) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))))
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (fma.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 im) (pow.f64 (exp.f64 im) #s(literal -2 binary64))))
(* 1/2 (* (sin re) (+ (exp (* -3 im)) (pow (exp im) 3))))
(.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(sin re)
(sin.f64 re)
(+ (sin re) (* 1/2 (* (pow im 2) (sin re))))
(.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (sin.f64 re))
(+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))
(fma.f64 (.f64 (sin.f64 re) (fma.f64 #s(literal 1/24 binary64) (.f64 im im) #s(literal 1/2 binary64))) (*.f64 im im) (sin.f64 re))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))
(fma.f64 (fma.f64 (.f64 (sin.f64 re) (fma.f64 #s(literal 1/720 binary64) (.f64 im im) #s(literal 1/24 binary64))) (.f64 im im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (*.f64 im im) (sin.f64 re))
1
#s(literal 1 binary64)
(+ 1 (* 1/2 (pow im 2)))
(fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))
(* 1/2 im)
(*.f64 im #s(literal 1/2 binary64))
(+ 1 im)
(+.f64 #s(literal 1 binary64) im)
(+ 1 (* im (+ 1 (* 1/2 im))))
(fma.f64 (fma.f64 im #s(literal 1/2 binary64) #s(literal 1 binary64)) im #s(literal 1 binary64))
(+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/6 binary64) im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) im #s(literal 1 binary64))
2
#s(literal 2 binary64)
(+ 2 (pow im 2))
(fma.f64 im im #s(literal 2 binary64))
(+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))
(fma.f64 (fma.f64 #s(literal 1/12 binary64) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64))
(+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))
(* 2 (sin re))
(*.f64 #s(literal 2 binary64) (sin.f64 re))
(+ (* 2 (sin re)) (* (pow im 2) (sin re)))
(*.f64 (fma.f64 im im #s(literal 2 binary64)) (sin.f64 re))
(+ (* 2 (sin re)) (* (pow im 2) (+ (sin re) (* 1/12 (* (pow im 2) (sin re))))))
(fma.f64 (.f64 (fma.f64 #s(literal 1/12 binary64) (.f64 im im) #s(literal 1 binary64)) (sin.f64 re)) (.f64 im im) (.f64 #s(literal 2 binary64) (sin.f64 re)))
(+ (* 2 (sin re)) (* (pow im 2) (+ (sin re) (* (pow im 2) (+ (* 1/360 (* (pow im 2) (sin re))) (* 1/12 (sin re)))))))
(fma.f64 (fma.f64 (.f64 (sin.f64 re) (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64))) (.f64 im im) (sin.f64 re)) (.f64 im im) (*.f64 #s(literal 2 binary64) (sin.f64 re)))
(+ 1 (* (pow im 2) (+ 1/2 (* 1/24 (pow im 2)))))
(fma.f64 (fma.f64 #s(literal 1/24 binary64) (.f64 im im) #s(literal 1/2 binary64)) (.f64 im im) #s(literal 1 binary64))
(+ 1 (* (pow im 2) (+ 1/2 (* (pow im 2) (+ 1/24 (* 1/720 (pow im 2)))))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/720 binary64) (.f64 im im) #s(literal 1/24 binary64)) (.f64 im im) #s(literal 1/2 binary64)) (*.f64 im im) #s(literal 1 binary64))
(* -3 im)
(*.f64 #s(literal -3 binary64) im)
(* -2 im)
(*.f64 #s(literal -2 binary64) im)
(+ (sin re) (* 1/2 (* (pow im 2) (- (* 9 (sin re)) (* 8 (sin re))))))
(.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (sin.f64 re))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (* 27/4 (sin re)) (+ (* 8/3 (sin re)) (* 4 (- (* 9 (sin re)) (* 8 (sin re)))))))) (* 1/2 (- (* 9 (sin re)) (* 8 (sin re)))))))
(fma.f64 (.f64 (fma.f64 (fma.f64 (sin.f64 re) #s(literal 49/12 binary64) (.f64 #s(literal -4 binary64) (sin.f64 re))) (.f64 im im) (sin.f64 re)) #s(literal 1/2 binary64)) (.f64 im im) (sin.f64 re))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (- (* 9 (sin re)) (* 8 (sin re)))) (* (pow im 2) (+ (* 1/2 (* (pow im 2) (- (* 81/40 (sin re)) (+ (* 16/45 (sin re)) (+ (* 4/3 (- (* 9 (sin re)) (* 8 (sin re)))) (* 4 (- (* 27/4 (sin re)) (+ (* 8/3 (sin re)) (* 4 (- (* 9 (sin re)) (* 8 (sin re)))))))))))) (* 1/2 (- (* 27/4 (sin re)) (+ (* 8/3 (sin re)) (* 4 (- (* 9 (sin re)) (* 8 (sin re))))))))))))
(fma.f64 (fma.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) (fma.f64 (-.f64 (.f64 (sin.f64 re) #s(literal 601/360 binary64)) (fma.f64 (fma.f64 (sin.f64 re) #s(literal 49/12 binary64) (.f64 #s(literal -4 binary64) (sin.f64 re))) #s(literal 4 binary64) (.f64 #s(literal 4/3 binary64) (sin.f64 re)))) (.f64 im im) (fma.f64 (sin.f64 re) #s(literal 49/12 binary64) (.f64 #s(literal -4 binary64) (sin.f64 re)))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (*.f64 im im) (sin.f64 re))
(+ (sin re) (* 9/2 (* (pow im 2) (sin re))))
(.f64 (fma.f64 (.f64 #s(literal 9/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))
(+ (sin re) (* (pow im 2) (+ (* 27/8 (* (pow im 2) (sin re))) (* 9/2 (sin re)))))
(fma.f64 (.f64 (sin.f64 re) (fma.f64 #s(literal 27/8 binary64) (.f64 im im) #s(literal 9/2 binary64))) (*.f64 im im) (sin.f64 re))
(+ (sin re) (* (pow im 2) (+ (* 9/2 (sin re)) (* (pow im 2) (+ (* 81/80 (* (pow im 2) (sin re))) (* 27/8 (sin re)))))))
(fma.f64 (fma.f64 (.f64 (sin.f64 re) (fma.f64 #s(literal 81/80 binary64) (.f64 im im) #s(literal 27/8 binary64))) (.f64 im im) (.f64 #s(literal 9/2 binary64) (sin.f64 re))) (*.f64 im im) (sin.f64 re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (* 1/3 (pow im 2))))
(.f64 (.f64 (fma.f64 #s(literal 1/3 binary64) (*.f64 im im) #s(literal 1 binary64)) im) im)
(* (pow im 2) (+ 1 (* (pow im 2) (+ 1/3 (* 2/45 (pow im 2))))))
(.f64 (.f64 (fma.f64 (fma.f64 #s(literal 2/45 binary64) (.f64 im im) #s(literal 1/3 binary64)) (.f64 im im) #s(literal 1 binary64)) im) im)
(* (pow im 2) (+ 1 (* (pow im 2) (+ 1/3 (* (pow im 2) (+ 2/45 (* 1/315 (pow im 2))))))))
(.f64 (.f64 (fma.f64 (fma.f64 (fma.f64 #s(literal 1/315 binary64) (.f64 im im) #s(literal 2/45 binary64)) (.f64 im im) #s(literal 1/3 binary64)) (*.f64 im im) #s(literal 1 binary64)) im) im)
im
(* im (+ 1 (* 1/6 (pow im 2))))
(.f64 (fma.f64 (.f64 #s(literal 1/6 binary64) im) im #s(literal 1 binary64)) im)
(* im (+ 1 (* (pow im 2) (+ 1/6 (* 1/120 (pow im 2))))))
(.f64 (fma.f64 (fma.f64 #s(literal 1/120 binary64) (.f64 im im) #s(literal 1/6 binary64)) (*.f64 im im) #s(literal 1 binary64)) im)
(* im (+ 1 (* (pow im 2) (+ 1/6 (* (pow im 2) (+ 1/120 (* 1/5040 (pow im 2))))))))
(.f64 (fma.f64 (fma.f64 (fma.f64 #s(literal 1/5040 binary64) (.f64 im im) #s(literal 1/120 binary64)) (.f64 im im) #s(literal 1/6 binary64)) (.f64 im im) #s(literal 1 binary64)) im)
(+ 1 (pow im 2))
(fma.f64 im im #s(literal 1 binary64))
(+ 1 (* (pow im 2) (+ 1 (* 1/3 (pow im 2)))))
(fma.f64 (fma.f64 #s(literal 1/3 binary64) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 1 binary64))
(+ 1 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/3 (* 2/45 (pow im 2)))))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 2/45 binary64) (.f64 im im) #s(literal 1/3 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 1 binary64))
(* 2 im)
(*.f64 #s(literal 2 binary64) im)
(* im (+ 2 (* 1/3 (pow im 2))))
(.f64 (fma.f64 #s(literal 1/3 binary64) (.f64 im im) #s(literal 2 binary64)) im)
(* im (+ 2 (* (pow im 2) (+ 1/3 (* 1/60 (pow im 2))))))
(.f64 (fma.f64 (fma.f64 #s(literal 1/60 binary64) (.f64 im im) #s(literal 1/3 binary64)) (*.f64 im im) #s(literal 2 binary64)) im)
(* im (+ 2 (* (pow im 2) (+ 1/3 (* (pow im 2) (+ 1/60 (* 1/2520 (pow im 2))))))))
(.f64 (fma.f64 (fma.f64 (fma.f64 #s(literal 1/2520 binary64) (.f64 im im) #s(literal 1/60 binary64)) (.f64 im im) #s(literal 1/3 binary64)) (.f64 im im) #s(literal 2 binary64)) im)
(+ 1 (* 3 im))
(fma.f64 #s(literal 3 binary64) im #s(literal 1 binary64))
(+ 1 (* im (+ 3 (* 9/2 im))))
(fma.f64 (fma.f64 #s(literal 9/2 binary64) im #s(literal 3 binary64)) im #s(literal 1 binary64))
(+ 1 (* im (+ 3 (* im (+ 9/2 (* 9/2 im))))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 9/2 binary64) im #s(literal 9/2 binary64)) im #s(literal 3 binary64)) im #s(literal 1 binary64))
(+ 1 (* 4 (pow im 2)))
(fma.f64 #s(literal 4 binary64) (*.f64 im im) #s(literal 1 binary64))
(+ 1 (* (pow im 2) (+ 4 (* 4/3 (pow im 2)))))
(fma.f64 (fma.f64 #s(literal 4/3 binary64) (.f64 im im) #s(literal 4 binary64)) (.f64 im im) #s(literal 1 binary64))
(+ 1 (* (pow im 2) (+ 4 (* (pow im 2) (+ 4/3 (* 8/45 (pow im 2)))))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 8/45 binary64) (.f64 im im) #s(literal 4/3 binary64)) (.f64 im im) #s(literal 4 binary64)) (*.f64 im im) #s(literal 1 binary64))
(* 1/2 (* (pow im 2) (sin re)))
(.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) im) im)
(* (pow im 2) (+ (* 1/2 (sin re)) (/ (sin re) (pow im 2))))
(.f64 (fma.f64 (sin.f64 re) #s(literal 1/2 binary64) (/.f64 (/.f64 (sin.f64 re) im) im)) (.f64 im im))
(* 1/2 (pow im 2))
(.f64 (.f64 im im) #s(literal 1/2 binary64))
(* (pow im 2) (+ 1/2 (/ 1 (pow im 2))))
(fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))
(- (* 1/4 (pow (+ (exp im) (/ 1 (exp im))) 2)) (* 1/4 (pow (- (exp im) (/ 1 (exp im))) 2)))
(*.f64 (-.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64))) #s(literal 1/4 binary64))
(/ (- (* 1/4 (pow (+ (exp im) (/ 1 (exp im))) 2)) (* 1/4 (pow (- (exp im) (/ 1 (exp im))) 2))) (exp (neg im)))
(/.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64))) #s(literal 1/4 binary64)) (exp.f64 (neg.f64 im)))
(- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))
(fma.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im)))
(+ (exp im) (/ 1 (exp im)))
(+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))
(* 1/2 (+ (exp im) (/ 1 (exp im))))
(fma.f64 (exp.f64 im) #s(literal 1/2 binary64) (/.f64 #s(literal 1/2 binary64) (exp.f64 im)))
(* 1/4 (pow (- (exp im) (/ 1 (exp im))) 2))
(*.f64 (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) #s(literal 1/4 binary64))
(* 1/2 (- (exp im) (/ 1 (exp im))))
(*.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 1/2 binary64))
(* 1/4 (pow (+ (exp im) (/ 1 (exp im))) 2))
(*.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) #s(literal 1/4 binary64))
(- (exp im) (exp (neg im)))
(-.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(pow (exp im) 3)
(pow.f64 (exp.f64 im) #s(literal 3 binary64))
(+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (neg im)))))
(fma.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 im) (pow.f64 (exp.f64 im) #s(literal -2 binary64)))
(* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))
(*.f64 (fma.f64 (exp.f64 im) #s(literal 1/2 binary64) (/.f64 #s(literal 1/2 binary64) (exp.f64 im))) (sin.f64 re))
(* 1/2 (* (sin re) (- (+ (exp (* -1 im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (* -1 im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (* -1 im)))))))
(.f64 (.f64 (fma.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im))) (sin.f64 re)) #s(literal 1/2 binary64))
(/ (- (* 1/4 (pow (+ (exp im) (/ 1 (exp im))) 2)) (* 1/4 (pow (- (exp im) (/ 1 (exp im))) 2))) (exp (* -1 im)))
(/.f64 (*.f64 (-.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64))) #s(literal 1/4 binary64)) (exp.f64 (neg.f64 im)))
(- (+ (exp (* -1 im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (* -1 im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (* -1 im)))))
(fma.f64 #s(literal 1/4 binary64) (/.f64 (-.f64 (pow.f64 (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im)))
(* 1/2 (/ (* (sin re) (+ (exp (* -3 im)) (pow (exp im) 3))) (+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (* -1 im)))))))
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (fma.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 im) (pow.f64 (exp.f64 im) #s(literal -2 binary64))))
(- (exp im) (exp (* -1 im)))
(-.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(+ (exp (* -2 im)) (* (exp im) (- (exp im) (exp (* -1 im)))))
(fma.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 im) (pow.f64 (exp.f64 im) #s(literal -2 binary64)))

rewrite94.0ms (1.3%)

Memory

-9.7MiB live, 130.5MiB allocated; 9ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	47	224
0	81	167
1	297	124
0	2354	122

Stop Event

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

Counts

23 → 517

Calls

Call 1

Inputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re)))
(.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64))
(*.f64 #s(literal 1/2 binary64) im)
(-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im)))
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im)))))
(/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im)))
(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im))))
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re))
(*.f64 #s(literal 2 binary64) (cosh.f64 im))
(cosh.f64 im)
(*.f64 (neg.f64 im) #s(literal 3 binary64))
(*.f64 (neg.f64 im) #s(literal 2 binary64))
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (.f64 (neg.f64 im) #s(literal 2 binary64)))))
(.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(sin.f64 re)
(*.f64 (sinh.f64 im) (sinh.f64 im))
(sinh.f64 im)
(*.f64 (cosh.f64 im) (cosh.f64 im))
(-.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(pow.f64 (exp.f64 im) #s(literal 3 binary64))
(fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (*.f64 (neg.f64 im) #s(literal 2 binary64))))

Outputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (sin.f64 re) (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))))
(.f64 (sin.f64 re) (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)))
(.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (sin.f64 re))
(/.f64 (.f64 (-.f64 (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 2 binary64)) #s(literal 1 binary64)) (sin.f64 re)) (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal -1 binary64)))
(/.f64 (.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (.f64 im im) #s(literal 3 binary64)) #s(literal 1 binary64)) (sin.f64 re)) (-.f64 (+.f64 (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 2 binary64)) #s(literal 1 binary64)) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(/.f64 (.f64 (sin.f64 re) (-.f64 (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 2 binary64)) #s(literal 1 binary64))) (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal -1 binary64)))
(/.f64 (.f64 (sin.f64 re) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (.f64 im im) #s(literal 3 binary64)) #s(literal 1 binary64))) (-.f64 (+.f64 (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 2 binary64)) #s(literal 1 binary64)) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(fma.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) (sin.f64 re) (*.f64 #s(literal 1 binary64) (sin.f64 re)))
(fma.f64 #s(literal 1 binary64) (sin.f64 re) (.f64 (.f64 (*.f64 im #s(literal 1/2 binary64)) im) (sin.f64 re)))
(fma.f64 (sin.f64 re) (.f64 (.f64 im #s(literal 1/2 binary64)) im) (*.f64 (sin.f64 re) #s(literal 1 binary64)))
(fma.f64 (sin.f64 re) #s(literal 1 binary64) (.f64 (sin.f64 re) (.f64 (*.f64 im #s(literal 1/2 binary64)) im)))
(+.f64 (.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) (sin.f64 re)) (.f64 #s(literal 1 binary64) (sin.f64 re)))
(+.f64 (.f64 #s(literal 1 binary64) (sin.f64 re)) (.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) (sin.f64 re)))
(+.f64 (.f64 (sin.f64 re) (.f64 (.f64 im #s(literal 1/2 binary64)) im)) (.f64 (sin.f64 re) #s(literal 1 binary64)))
(+.f64 (.f64 (sin.f64 re) #s(literal 1 binary64)) (.f64 (sin.f64 re) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 2 binary64))) (-.f64 #s(literal 1 binary64) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 2 binary64)) #s(literal 1 binary64))) (neg.f64 (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal -1 binary64))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (.f64 im im) #s(literal 3 binary64)) #s(literal 1 binary64))) (neg.f64 (-.f64 (+.f64 (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 2 binary64)) #s(literal 1 binary64)) (.f64 (*.f64 im #s(literal 1/2 binary64)) im))))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 2 binary64)) #s(literal 1 binary64)) (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal -1 binary64)))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (.f64 im im) #s(literal 3 binary64)) #s(literal 1 binary64)) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 2 binary64)) (.f64 (*.f64 im #s(literal 1/2 binary64)) im))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (.f64 im im) #s(literal 3 binary64)) #s(literal 1 binary64)) (-.f64 (+.f64 (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 2 binary64)) #s(literal 1 binary64)) (.f64 (*.f64 im #s(literal 1/2 binary64)) im)))
(fma.f64 (.f64 (.f64 (*.f64 im #s(literal 1/2 binary64)) im) (exp.f64 im)) (exp.f64 (neg.f64 im)) #s(literal 1 binary64))
(fma.f64 (neg.f64 (neg.f64 (cosh.f64 im))) (neg.f64 (neg.f64 (cosh.f64 im))) (fma.f64 (sinh.f64 (neg.f64 im)) (sinh.f64 im) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(fma.f64 (neg.f64 (fabs.f64 (cosh.f64 im))) (neg.f64 (fabs.f64 (cosh.f64 im))) (fma.f64 (sinh.f64 (neg.f64 im)) (sinh.f64 im) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(fma.f64 (fabs.f64 (fabs.f64 (cosh.f64 im))) (fabs.f64 (fabs.f64 (cosh.f64 im))) (fma.f64 (sinh.f64 (neg.f64 im)) (sinh.f64 im) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(fma.f64 (pow.f64 (cosh.f64 im) #s(literal 1 binary64)) (pow.f64 (cosh.f64 im) #s(literal 1 binary64)) (fma.f64 (sinh.f64 (neg.f64 im)) (sinh.f64 im) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(fma.f64 (pow.f64 (cosh.f64 im) #s(literal 1 binary64)) (cosh.f64 im) (fma.f64 (sinh.f64 (neg.f64 im)) (sinh.f64 im) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))
(fma.f64 (neg.f64 (cosh.f64 im)) (neg.f64 (cosh.f64 im)) (fma.f64 (sinh.f64 (neg.f64 im)) (sinh.f64 im) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(fma.f64 (fabs.f64 (cosh.f64 im)) (fabs.f64 (cosh.f64 im)) (fma.f64 (sinh.f64 (neg.f64 im)) (sinh.f64 im) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(fma.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 1 binary64) #s(literal 1 binary64))
(fma.f64 #s(literal 1 binary64) (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 1 binary64))
(fma.f64 (cosh.f64 im) (cosh.f64 im) (fma.f64 (sinh.f64 (neg.f64 im)) (sinh.f64 im) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(fma.f64 (.f64 im #s(literal 1/2 binary64)) (.f64 im #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 (*.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))
(fma.f64 im (.f64 (.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 im (*.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64))
(fma.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) #s(literal 1 binary64)) #s(literal 1 binary64))
(fma.f64 #s(literal 1/2 binary64) (*.f64 im im) #s(literal 1 binary64))
(-.f64 (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) (pow.f64 (cosh.f64 im) #s(literal 2 binary64))) (pow.f64 (sinh.f64 im) #s(literal 2 binary64)))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 2 binary64)) (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal -1 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal -1 binary64))))
(-.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal -1 binary64))
(-.f64 #s(literal 1 binary64) (.f64 (neg.f64 (.f64 im #s(literal 1/2 binary64))) im))
(-.f64 #s(literal 1 binary64) (.f64 (neg.f64 im) (.f64 im #s(literal 1/2 binary64))))
(-.f64 #s(literal 1 binary64) (.f64 #s(literal -1/2 binary64) (.f64 im im)))
(-.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (-.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(+.f64 (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) (pow.f64 (cosh.f64 im) #s(literal 2 binary64))) (neg.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64))))
(+.f64 (/.f64 (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 2 binary64)) #s(literal 1 binary64)) (.f64 (.f64 im #s(literal 1/2 binary64)) im))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 (pow.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 2 binary64)) #s(literal 1 binary64)) (.f64 (.f64 im #s(literal 1/2 binary64)) im))))
(+.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) (.f64 (.f64 im #s(literal 1/2 binary64)) im))
(+.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (fma.f64 (sinh.f64 (neg.f64 im)) (sinh.f64 im) (.f64 (.f64 im #s(literal 1/2 binary64)) im)))
(*.f64 im #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) im)
#s(literal 1 binary64)
(.f64 (/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (-.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 4 binary64)))) (-.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64)))))
(.f64 (/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (+.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 3 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64)))) (fma.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (expm1.f64 (+.f64 im im))) (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64))))
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re))
(.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (cosh.f64 im))
(.f64 (.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (cosh.f64 im))) (sin.f64 re))
(.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im)) #s(literal 2 binary64))
(.f64 (/.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))) (.f64 #s(literal 2 binary64) (cosh.f64 (*.f64 #s(literal 3 binary64) im))))
(.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) (/.f64 #s(literal 1/2 binary64) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (/.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 2 binary64)) (cosh.f64 im)) #s(literal 1/2 binary64))
(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 (cosh.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im)))
(.f64 #s(literal 1 binary64) (.f64 (cosh.f64 im) (sin.f64 re)))
(.f64 (cosh.f64 im) (.f64 #s(literal 2 binary64) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(.f64 (sin.f64 re) (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64)))
(.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
(.f64 #s(literal 1/2 binary64) (.f64 (*.f64 (sin.f64 re) #s(literal 2 binary64)) (cosh.f64 im)))
(/.f64 (.f64 (-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64))) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(/.f64 (.f64 (-.f64 (pow.f64 (exp.f64 im) #s(literal 6 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64))) (/.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64)))))) (.f64 #s(literal 2 binary64) (sinh.f64 (*.f64 #s(literal 3 binary64) im))))
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 9 binary64)) (pow.f64 (exp.f64 im) #s(literal 9 binary64))) (/.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64)))))) (+.f64 (expm1.f64 (.f64 (*.f64 im #s(literal -3 binary64)) #s(literal 2 binary64))) (pow.f64 (exp.f64 im) #s(literal 6 binary64))))
(/.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64)))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(/.f64 (-.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))) (-.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re))))
(/.f64 (+.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64))) (fma.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (-.f64 (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re))) (.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re))))))
(/.f64 (neg.f64 (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) #s(literal -1/2 binary64))) (neg.f64 (neg.f64 (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))))
(/.f64 (.f64 (-.f64 (pow.f64 (exp.f64 im) #s(literal 6 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 (.f64 #s(literal 3 binary64) im))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))))
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 9 binary64)) (pow.f64 (exp.f64 im) #s(literal 9 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (+.f64 (expm1.f64 (.f64 (.f64 im #s(literal -3 binary64)) #s(literal 2 binary64))) (pow.f64 (exp.f64 im) #s(literal 6 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))))
(/.f64 (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) #s(literal -1/2 binary64)) (neg.f64 (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))
(neg.f64 (/.f64 (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) #s(literal -1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(neg.f64 (/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (neg.f64 (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))))
(fma.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im)) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im) (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im)))
(fma.f64 (cosh.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (cosh.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) (exp.f64 (neg.f64 im))) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 #s(literal 1/2 binary64) (.f64 (sin.f64 re) (exp.f64 im)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1/2 binary64) (.f64 (sin.f64 re) (exp.f64 (neg.f64 im))) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(-.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (neg.f64 (exp.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(-.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (neg.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (exp.f64 im)))
(+.f64 (.f64 (cosh.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (cosh.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im)) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im)))
(+.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(*.f64 (exp.f64 im) (/.f64 (exp.f64 (neg.f64 im)) (exp.f64 (neg.f64 im))))
(*.f64 #s(literal 1 binary64) (exp.f64 im))
(pow.f64 (exp.f64 (neg.f64 im)) #s(literal -1 binary64))
(/.f64 (-.f64 (.f64 (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im)))) (.f64 (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))))) (fma.f64 (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1 binary64)) (exp.f64 im) (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im)))))
(/.f64 (-.f64 (pow.f64 (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) #s(literal 3 binary64))) (fma.f64 (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (fma.f64 (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (*.f64 (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im)))))))
(/.f64 (+.f64 (pow.f64 (cosh.f64 im) #s(literal 3 binary64)) (pow.f64 (sinh.f64 im) #s(literal 3 binary64))) (fma.f64 (cosh.f64 im) (cosh.f64 im) (-.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (*.f64 (cosh.f64 im) (sinh.f64 im)))))
(/.f64 (fma.f64 #s(literal 2 binary64) (cosh.f64 im) (*.f64 #s(literal 2 binary64) (sinh.f64 im))) #s(literal 2 binary64))
(/.f64 (-.f64 (.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (exp.f64 (neg.f64 im)) (pow.f64 (sinh.f64 im) #s(literal 2 binary64)))) (exp.f64 (*.f64 im #s(literal -2 binary64))))
(/.f64 (fma.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 2 binary64) (.f64 #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (sinh.f64 im)))) #s(literal 4 binary64))
(/.f64 (.f64 (cosh.f64 (+.f64 im im)) #s(literal 1 binary64)) (.f64 (cosh.f64 (+.f64 im im)) (exp.f64 (neg.f64 im))))
(/.f64 (-.f64 (pow.f64 (cosh.f64 im) #s(literal 6 binary64)) (pow.f64 (sinh.f64 im) #s(literal 6 binary64))) (*.f64 (fma.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (cosh.f64 (+.f64 im im)) (pow.f64 (cosh.f64 im) #s(literal 4 binary64))) (exp.f64 (neg.f64 im))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (exp.f64 im)))
(/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 #s(literal -1 binary64) (exp.f64 im))))
(/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)))
(neg.f64 (/.f64 #s(literal -1 binary64) (exp.f64 (neg.f64 im))))
(neg.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (exp.f64 im))))
(fma.f64 (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1 binary64)) (exp.f64 im) (/.f64 (neg.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))))
(fma.f64 (neg.f64 (cosh.f64 im)) (/.f64 (neg.f64 (cosh.f64 im)) (exp.f64 (neg.f64 im))) (/.f64 (neg.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))))
(fma.f64 (fabs.f64 (cosh.f64 im)) (/.f64 (fabs.f64 (cosh.f64 im)) (exp.f64 (neg.f64 im))) (/.f64 (neg.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))))
(fma.f64 #s(literal 2 binary64) (/.f64 (sinh.f64 im) #s(literal 2 binary64)) (cosh.f64 im))
(fma.f64 #s(literal 2 binary64) (/.f64 (cosh.f64 im) #s(literal 2 binary64)) (sinh.f64 im))
(fma.f64 (cosh.f64 im) (/.f64 (cosh.f64 im) (exp.f64 (neg.f64 im))) (/.f64 (neg.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))))
(fma.f64 (cosh.f64 im) #s(literal 1 binary64) (sinh.f64 im))
(-.f64 (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))))
(exp.f64 (-.f64 #s(literal 0 binary64) (neg.f64 im)))
(exp.f64 (neg.f64 (neg.f64 im)))
(exp.f64 im)
(+.f64 (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (/.f64 (neg.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64))) (exp.f64 (neg.f64 im))))
(+.f64 (sinh.f64 im) (cosh.f64 im))
(+.f64 (cosh.f64 im) (sinh.f64 im))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 (/.f64 (*.f64 im #s(literal -2 binary64)) #s(literal 2 binary64))) (cosh.f64 (/.f64 (-.f64 (neg.f64 im) (neg.f64 im)) #s(literal 2 binary64)))))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 (/.f64 (+.f64 (neg.f64 im) im) #s(literal 2 binary64))) (cosh.f64 (/.f64 (-.f64 (neg.f64 im) im) #s(literal 2 binary64)))))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 (/.f64 (+.f64 im (neg.f64 im)) #s(literal 2 binary64))) (cosh.f64 (/.f64 (-.f64 im (neg.f64 im)) #s(literal 2 binary64)))))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 (/.f64 (+.f64 im im) #s(literal 2 binary64))) #s(literal 1 binary64)))
(*.f64 #s(literal 2 binary64) (cosh.f64 im))
(*.f64 (cosh.f64 im) #s(literal 2 binary64))
(/.f64 (-.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (pow.f64 (cosh.f64 im) #s(literal 2 binary64))) (-.f64 (cosh.f64 im) (cosh.f64 im)))
(/.f64 (+.f64 (pow.f64 (cosh.f64 im) #s(literal 3 binary64)) (pow.f64 (cosh.f64 im) #s(literal 3 binary64))) (fma.f64 (cosh.f64 im) (cosh.f64 im) (-.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (pow.f64 (cosh.f64 im) #s(literal 2 binary64)))))
(/.f64 (fma.f64 #s(literal 2 binary64) (cosh.f64 im) (*.f64 #s(literal 2 binary64) (cosh.f64 im))) #s(literal 2 binary64))
(/.f64 (neg.f64 (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64)))) (neg.f64 (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))))
(/.f64 (neg.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im)))) (neg.f64 (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(/.f64 (fma.f64 #s(literal -1 binary64) (exp.f64 im) (.f64 (/.f64 #s(literal -1 binary64) (exp.f64 im)) #s(literal 1 binary64))) (.f64 (/.f64 #s(literal -1 binary64) (exp.f64 im)) (exp.f64 im)))
(/.f64 (+.f64 (exp.f64 im) (*.f64 (exp.f64 (neg.f64 im)) #s(literal 1 binary64))) #s(literal 1 binary64))
(/.f64 (fma.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (exp.f64 im)) (*.f64 (exp.f64 im) #s(literal -1 binary64))) #s(literal -1 binary64))
(/.f64 (+.f64 (exp.f64 (neg.f64 im)) (*.f64 (exp.f64 im) #s(literal 1 binary64))) #s(literal 1 binary64))
(/.f64 (fma.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 2 binary64) (.f64 #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (cosh.f64 im)))) #s(literal 4 binary64))
(/.f64 (.f64 #s(literal 2 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im))) #s(literal 2 binary64))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 2 binary64)) #s(literal 2 binary64))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (.f64 #s(literal 2 binary64) (sinh.f64 im))) (.f64 #s(literal 2 binary64) (sinh.f64 im)))
(/.f64 (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(/.f64 (-.f64 (pow.f64 (exp.f64 im) #s(literal 6 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64))) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 (.f64 #s(literal 3 binary64) im))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))))
(/.f64 (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 9 binary64)) (pow.f64 (exp.f64 im) #s(literal 9 binary64))) (.f64 (+.f64 (expm1.f64 (.f64 (.f64 im #s(literal -3 binary64)) #s(literal 2 binary64))) (pow.f64 (exp.f64 im) #s(literal 6 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))))
(/.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (fma.f64 (exp.f64 im) (exp.f64 im) (expm1.f64 (*.f64 im #s(literal -2 binary64)))))
(/.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))
(fma.f64 (exp.f64 im) (/.f64 (exp.f64 (neg.f64 im)) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im)))
(fma.f64 (exp.f64 im) (exp.f64 (*.f64 im #s(literal -2 binary64))) (exp.f64 im))
(fma.f64 #s(literal 2 binary64) (/.f64 (cosh.f64 im) #s(literal 2 binary64)) (+.f64 (sinh.f64 im) (exp.f64 (neg.f64 im))))
(fma.f64 #s(literal 2 binary64) (/.f64 (cosh.f64 im) #s(literal 2 binary64)) (+.f64 (sinh.f64 (neg.f64 im)) (exp.f64 im)))
(fma.f64 #s(literal 2 binary64) (/.f64 (cosh.f64 im) #s(literal 2 binary64)) (cosh.f64 im))
(fma.f64 #s(literal 1 binary64) (exp.f64 im) (exp.f64 (neg.f64 im)))
(fma.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)) (exp.f64 im))
(fma.f64 #s(literal 1 binary64) (cosh.f64 im) (*.f64 #s(literal 1 binary64) (cosh.f64 im)))
(fma.f64 (cosh.f64 im) #s(literal 1 binary64) (+.f64 (sinh.f64 im) (exp.f64 (neg.f64 im))))
(fma.f64 (cosh.f64 im) #s(literal 1 binary64) (+.f64 (sinh.f64 (neg.f64 im)) (exp.f64 im)))
(fma.f64 (cosh.f64 im) #s(literal 1 binary64) (cosh.f64 im))
(-.f64 (+.f64 (exp.f64 (neg.f64 im)) (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im)))) (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))))
(-.f64 (+.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 im))
(-.f64 (/.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) (/.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))))
(-.f64 (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (-.f64 (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im))))
(-.f64 (cosh.f64 im) (-.f64 (sinh.f64 im) (exp.f64 im)))
(+.f64 (+.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 (neg.f64 im)))
(+.f64 (+.f64 (exp.f64 (neg.f64 im)) (cosh.f64 im)) (sinh.f64 im))
(+.f64 (/.f64 (exp.f64 (.f64 im #s(literal -3 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))) (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(+.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))) (/.f64 (exp.f64 (.f64 im #s(literal -3 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(+.f64 (.f64 #s(literal 1 binary64) (cosh.f64 im)) (.f64 #s(literal 1 binary64) (cosh.f64 im)))
(+.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))
(+.f64 (cosh.f64 im) (+.f64 (sinh.f64 im) (exp.f64 (neg.f64 im))))
(+.f64 (cosh.f64 im) (+.f64 (sinh.f64 (neg.f64 im)) (exp.f64 im)))
(+.f64 (cosh.f64 im) (cosh.f64 im))
(.f64 (/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (-.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 4 binary64)))) (-.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64)))))
(.f64 (/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (+.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 3 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64)))) (fma.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (expm1.f64 (+.f64 im im))) (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64))))
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re))
(.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (cosh.f64 im))
(.f64 (.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (cosh.f64 im))) (sin.f64 re))
(.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im)) #s(literal 2 binary64))
(.f64 (/.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))) (.f64 #s(literal 2 binary64) (cosh.f64 (*.f64 #s(literal 3 binary64) im))))
(.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) (/.f64 #s(literal 1/2 binary64) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (/.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 2 binary64)) (cosh.f64 im)) #s(literal 1/2 binary64))
(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 (cosh.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im)))
(.f64 #s(literal 1 binary64) (.f64 (cosh.f64 im) (sin.f64 re)))
(.f64 (cosh.f64 im) (.f64 #s(literal 2 binary64) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(.f64 (sin.f64 re) (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64)))
(.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
(.f64 #s(literal 1/2 binary64) (.f64 (*.f64 (sin.f64 re) #s(literal 2 binary64)) (cosh.f64 im)))
(/.f64 (.f64 (-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64))) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(/.f64 (.f64 (-.f64 (pow.f64 (exp.f64 im) #s(literal 6 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64))) (/.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64)))))) (.f64 #s(literal 2 binary64) (sinh.f64 (*.f64 #s(literal 3 binary64) im))))
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 9 binary64)) (pow.f64 (exp.f64 im) #s(literal 9 binary64))) (/.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64)))))) (+.f64 (expm1.f64 (.f64 (*.f64 im #s(literal -3 binary64)) #s(literal 2 binary64))) (pow.f64 (exp.f64 im) #s(literal 6 binary64))))
(/.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64)))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(/.f64 (-.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))) (-.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re))))
(/.f64 (+.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64))) (fma.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (-.f64 (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re))) (.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re))))))
(/.f64 (neg.f64 (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) #s(literal -1/2 binary64))) (neg.f64 (neg.f64 (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))))
(/.f64 (.f64 (-.f64 (pow.f64 (exp.f64 im) #s(literal 6 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 (.f64 #s(literal 3 binary64) im))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))))
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 9 binary64)) (pow.f64 (exp.f64 im) #s(literal 9 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (+.f64 (expm1.f64 (.f64 (.f64 im #s(literal -3 binary64)) #s(literal 2 binary64))) (pow.f64 (exp.f64 im) #s(literal 6 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))))
(/.f64 (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) #s(literal -1/2 binary64)) (neg.f64 (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))
(neg.f64 (/.f64 (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) #s(literal -1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(neg.f64 (/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (neg.f64 (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))))
(fma.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im)) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im) (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im)))
(fma.f64 (cosh.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (cosh.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) (exp.f64 (neg.f64 im))) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 #s(literal 1/2 binary64) (.f64 (sin.f64 re) (exp.f64 im)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1/2 binary64) (.f64 (sin.f64 re) (exp.f64 (neg.f64 im))) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(-.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (neg.f64 (exp.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(-.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (neg.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (exp.f64 im)))
(+.f64 (.f64 (cosh.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (cosh.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im)) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im)))
(+.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(.f64 (.f64 (sin.f64 re) #s(literal 2 binary64)) (cosh.f64 im))
(.f64 (.f64 (cosh.f64 im) (sin.f64 re)) #s(literal 2 binary64))
(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 im) (sin.f64 re)))
(.f64 (cosh.f64 im) (.f64 #s(literal 2 binary64) (sin.f64 re)))
(.f64 (sin.f64 re) (.f64 #s(literal 2 binary64) (cosh.f64 im)))
(/.f64 (.f64 (-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64))) (sin.f64 re)) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(/.f64 (.f64 (sin.f64 re) (-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64)))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64)))))
(fma.f64 (exp.f64 im) (sin.f64 re) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))
(fma.f64 (exp.f64 (neg.f64 im)) (sin.f64 re) (*.f64 (exp.f64 im) (sin.f64 re)))
(fma.f64 (cosh.f64 im) (sin.f64 re) (*.f64 (cosh.f64 im) (sin.f64 re)))
(fma.f64 (sin.f64 re) (exp.f64 im) (*.f64 (sin.f64 re) (exp.f64 (neg.f64 im))))
(fma.f64 (sin.f64 re) (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) (exp.f64 im)))
(fma.f64 (sin.f64 re) (cosh.f64 im) (*.f64 (cosh.f64 im) (sin.f64 re)))
(+.f64 (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))
(+.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) (.f64 (exp.f64 im) (sin.f64 re)))
(+.f64 (.f64 (sin.f64 re) (exp.f64 im)) (.f64 (sin.f64 re) (exp.f64 (neg.f64 im))))
(+.f64 (.f64 (sin.f64 re) (exp.f64 (neg.f64 im))) (.f64 (sin.f64 re) (exp.f64 im)))
(+.f64 (.f64 (cosh.f64 im) (sin.f64 re)) (.f64 (cosh.f64 im) (sin.f64 re)))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 (/.f64 (*.f64 im #s(literal -2 binary64)) #s(literal 2 binary64))) (cosh.f64 (/.f64 (-.f64 (neg.f64 im) (neg.f64 im)) #s(literal 2 binary64)))))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 (/.f64 (+.f64 (neg.f64 im) im) #s(literal 2 binary64))) (cosh.f64 (/.f64 (-.f64 (neg.f64 im) im) #s(literal 2 binary64)))))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 (/.f64 (+.f64 im (neg.f64 im)) #s(literal 2 binary64))) (cosh.f64 (/.f64 (-.f64 im (neg.f64 im)) #s(literal 2 binary64)))))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 (/.f64 (+.f64 im im) #s(literal 2 binary64))) #s(literal 1 binary64)))
(*.f64 #s(literal 2 binary64) (cosh.f64 im))
(*.f64 (cosh.f64 im) #s(literal 2 binary64))
(/.f64 (-.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (pow.f64 (cosh.f64 im) #s(literal 2 binary64))) (-.f64 (cosh.f64 im) (cosh.f64 im)))
(/.f64 (+.f64 (pow.f64 (cosh.f64 im) #s(literal 3 binary64)) (pow.f64 (cosh.f64 im) #s(literal 3 binary64))) (fma.f64 (cosh.f64 im) (cosh.f64 im) (-.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (pow.f64 (cosh.f64 im) #s(literal 2 binary64)))))
(/.f64 (fma.f64 #s(literal 2 binary64) (cosh.f64 im) (*.f64 #s(literal 2 binary64) (cosh.f64 im))) #s(literal 2 binary64))
(/.f64 (neg.f64 (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64)))) (neg.f64 (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))))
(/.f64 (neg.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im)))) (neg.f64 (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(/.f64 (fma.f64 #s(literal -1 binary64) (exp.f64 im) (.f64 (/.f64 #s(literal -1 binary64) (exp.f64 im)) #s(literal 1 binary64))) (.f64 (/.f64 #s(literal -1 binary64) (exp.f64 im)) (exp.f64 im)))
(/.f64 (+.f64 (exp.f64 im) (*.f64 (exp.f64 (neg.f64 im)) #s(literal 1 binary64))) #s(literal 1 binary64))
(/.f64 (fma.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (exp.f64 im)) (*.f64 (exp.f64 im) #s(literal -1 binary64))) #s(literal -1 binary64))
(/.f64 (+.f64 (exp.f64 (neg.f64 im)) (*.f64 (exp.f64 im) #s(literal 1 binary64))) #s(literal 1 binary64))
(/.f64 (fma.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 2 binary64) (.f64 #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (cosh.f64 im)))) #s(literal 4 binary64))
(/.f64 (.f64 #s(literal 2 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im))) #s(literal 2 binary64))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 2 binary64)) #s(literal 2 binary64))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (.f64 #s(literal 2 binary64) (sinh.f64 im))) (.f64 #s(literal 2 binary64) (sinh.f64 im)))
(/.f64 (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(/.f64 (-.f64 (pow.f64 (exp.f64 im) #s(literal 6 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64))) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 (.f64 #s(literal 3 binary64) im))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))))
(/.f64 (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 9 binary64)) (pow.f64 (exp.f64 im) #s(literal 9 binary64))) (.f64 (+.f64 (expm1.f64 (.f64 (.f64 im #s(literal -3 binary64)) #s(literal 2 binary64))) (pow.f64 (exp.f64 im) #s(literal 6 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))))
(/.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (fma.f64 (exp.f64 im) (exp.f64 im) (expm1.f64 (*.f64 im #s(literal -2 binary64)))))
(/.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))
(fma.f64 (exp.f64 im) (/.f64 (exp.f64 (neg.f64 im)) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im)))
(fma.f64 (exp.f64 im) (exp.f64 (*.f64 im #s(literal -2 binary64))) (exp.f64 im))
(fma.f64 #s(literal 2 binary64) (/.f64 (cosh.f64 im) #s(literal 2 binary64)) (+.f64 (sinh.f64 im) (exp.f64 (neg.f64 im))))
(fma.f64 #s(literal 2 binary64) (/.f64 (cosh.f64 im) #s(literal 2 binary64)) (+.f64 (sinh.f64 (neg.f64 im)) (exp.f64 im)))
(fma.f64 #s(literal 2 binary64) (/.f64 (cosh.f64 im) #s(literal 2 binary64)) (cosh.f64 im))
(fma.f64 #s(literal 1 binary64) (exp.f64 im) (exp.f64 (neg.f64 im)))
(fma.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)) (exp.f64 im))
(fma.f64 #s(literal 1 binary64) (cosh.f64 im) (*.f64 #s(literal 1 binary64) (cosh.f64 im)))
(fma.f64 (cosh.f64 im) #s(literal 1 binary64) (+.f64 (sinh.f64 im) (exp.f64 (neg.f64 im))))
(fma.f64 (cosh.f64 im) #s(literal 1 binary64) (+.f64 (sinh.f64 (neg.f64 im)) (exp.f64 im)))
(fma.f64 (cosh.f64 im) #s(literal 1 binary64) (cosh.f64 im))
(-.f64 (+.f64 (exp.f64 (neg.f64 im)) (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im)))) (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))))
(-.f64 (+.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 im))
(-.f64 (/.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) (/.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))))
(-.f64 (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (-.f64 (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (exp.f64 (neg.f64 im))) (exp.f64 (neg.f64 im))))
(-.f64 (cosh.f64 im) (-.f64 (sinh.f64 im) (exp.f64 im)))
(+.f64 (+.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 (neg.f64 im)))
(+.f64 (+.f64 (exp.f64 (neg.f64 im)) (cosh.f64 im)) (sinh.f64 im))
(+.f64 (/.f64 (exp.f64 (.f64 im #s(literal -3 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))) (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(+.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))) (/.f64 (exp.f64 (.f64 im #s(literal -3 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(+.f64 (.f64 #s(literal 1 binary64) (cosh.f64 im)) (.f64 #s(literal 1 binary64) (cosh.f64 im)))
(+.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))
(+.f64 (cosh.f64 im) (+.f64 (sinh.f64 im) (exp.f64 (neg.f64 im))))
(+.f64 (cosh.f64 im) (+.f64 (sinh.f64 (neg.f64 im)) (exp.f64 im)))
(+.f64 (cosh.f64 im) (cosh.f64 im))
(*.f64 #s(literal 2 binary64) (/.f64 (cosh.f64 im) #s(literal 2 binary64)))
(*.f64 (cosh.f64 im) #s(literal 1 binary64))
(/.f64 (neg.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im))) #s(literal -2 binary64))
(/.f64 (-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64))) (.f64 (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)) #s(literal 2 binary64)))
(/.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64)))) #s(literal 2 binary64)))
(/.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 2 binary64))
(cosh.f64 (neg.f64 (neg.f64 im)))
(cosh.f64 (neg.f64 im))
(cosh.f64 im)
(-.f64 (.f64 #s(literal 1 binary64) (cosh.f64 im)) (.f64 #s(literal 0 binary64) (sinh.f64 im)))
(+.f64 (/.f64 (cosh.f64 im) #s(literal 2 binary64)) (/.f64 (cosh.f64 im) #s(literal 2 binary64)))
(+.f64 (/.f64 (exp.f64 (neg.f64 im)) #s(literal 2 binary64)) (/.f64 (exp.f64 im) #s(literal 2 binary64)))
(+.f64 (/.f64 (exp.f64 im) #s(literal 2 binary64)) (/.f64 (exp.f64 (neg.f64 im)) #s(literal 2 binary64)))
(*.f64 #s(literal 3 binary64) (neg.f64 im))
(*.f64 (neg.f64 im) #s(literal 3 binary64))
(*.f64 im #s(literal -3 binary64))
(/.f64 (.f64 (.f64 im (neg.f64 im)) #s(literal 3 binary64)) im)
(/.f64 (.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) #s(literal 3 binary64)) (.f64 im im))
(/.f64 (.f64 #s(literal 3 binary64) (.f64 im (neg.f64 im))) im)
(/.f64 (.f64 #s(literal 3 binary64) (neg.f64 (pow.f64 im #s(literal 3 binary64)))) (.f64 im im))
(neg.f64 (*.f64 #s(literal 3 binary64) im))
(*.f64 #s(literal 2 binary64) (neg.f64 im))
(*.f64 (neg.f64 im) #s(literal 2 binary64))
(*.f64 im #s(literal -2 binary64))
(/.f64 (.f64 (.f64 im (neg.f64 im)) #s(literal 2 binary64)) im)
(/.f64 (.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) #s(literal 2 binary64)) (.f64 im im))
(/.f64 (.f64 #s(literal 2 binary64) (.f64 im (neg.f64 im))) im)
(/.f64 (.f64 #s(literal 2 binary64) (neg.f64 (pow.f64 im #s(literal 3 binary64)))) (.f64 im im))
(neg.f64 (*.f64 #s(literal 2 binary64) im))
(fma.f64 (neg.f64 im) #s(literal 1 binary64) (*.f64 (neg.f64 im) #s(literal 1 binary64)))
(fma.f64 #s(literal 1 binary64) (neg.f64 im) (*.f64 #s(literal 1 binary64) (neg.f64 im)))
(+.f64 (.f64 #s(literal 1 binary64) (neg.f64 im)) (.f64 #s(literal 1 binary64) (neg.f64 im)))
(+.f64 (.f64 (neg.f64 im) #s(literal 1 binary64)) (.f64 (neg.f64 im) #s(literal 1 binary64)))
(+.f64 (neg.f64 im) (neg.f64 im))
(.f64 (/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (-.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 4 binary64)))) (-.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64)))))
(.f64 (/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (+.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 3 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64)))) (fma.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (expm1.f64 (+.f64 im im))) (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64))))
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re))
(.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (cosh.f64 im))
(.f64 (.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (cosh.f64 im))) (sin.f64 re))
(.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im)) #s(literal 2 binary64))
(.f64 (/.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))) (.f64 #s(literal 2 binary64) (cosh.f64 (*.f64 #s(literal 3 binary64) im))))
(.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) (/.f64 #s(literal 1/2 binary64) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (/.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 2 binary64)) (cosh.f64 im)) #s(literal 1/2 binary64))
(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 #s(literal 2 binary64) (.f64 (*.f64 (cosh.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im)))
(.f64 #s(literal 1 binary64) (.f64 (cosh.f64 im) (sin.f64 re)))
(.f64 (cosh.f64 im) (.f64 #s(literal 2 binary64) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(.f64 (sin.f64 re) (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64)))
(.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
(.f64 #s(literal 1/2 binary64) (.f64 (*.f64 (sin.f64 re) #s(literal 2 binary64)) (cosh.f64 im)))
(/.f64 (.f64 (-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64))) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(/.f64 (.f64 (-.f64 (pow.f64 (exp.f64 im) #s(literal 6 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64))) (/.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64)))))) (.f64 #s(literal 2 binary64) (sinh.f64 (*.f64 #s(literal 3 binary64) im))))
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 9 binary64)) (pow.f64 (exp.f64 im) #s(literal 9 binary64))) (/.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64)))))) (+.f64 (expm1.f64 (.f64 (*.f64 im #s(literal -3 binary64)) #s(literal 2 binary64))) (pow.f64 (exp.f64 im) #s(literal 6 binary64))))
(/.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64)))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(/.f64 (-.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))) (-.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re))))
(/.f64 (+.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64))) (fma.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (-.f64 (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re))) (.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re))))))
(/.f64 (neg.f64 (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) #s(literal -1/2 binary64))) (neg.f64 (neg.f64 (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))))
(/.f64 (.f64 (-.f64 (pow.f64 (exp.f64 im) #s(literal 6 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 (.f64 #s(literal 3 binary64) im))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))))
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 9 binary64)) (pow.f64 (exp.f64 im) #s(literal 9 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (+.f64 (expm1.f64 (.f64 (.f64 im #s(literal -3 binary64)) #s(literal 2 binary64))) (pow.f64 (exp.f64 im) #s(literal 6 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))))
(/.f64 (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) #s(literal -1/2 binary64)) (neg.f64 (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))
(neg.f64 (/.f64 (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) #s(literal -1/2 binary64)) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(neg.f64 (/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (neg.f64 (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))))
(fma.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im)) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im) (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im)))
(fma.f64 (cosh.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (cosh.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) (exp.f64 (neg.f64 im))) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 #s(literal 1/2 binary64) (.f64 (sin.f64 re) (exp.f64 im)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1/2 binary64) (.f64 (sin.f64 re) (exp.f64 (neg.f64 im))) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(-.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (neg.f64 (exp.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(-.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (neg.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (exp.f64 im)))
(+.f64 (.f64 (cosh.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (cosh.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im)) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (cosh.f64 im)))
(+.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) #s(literal 1/2 binary64)) (sin.f64 re))
(.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)) #s(literal 1/2 binary64))
(.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))))
(.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im)))))
(.f64 #s(literal 1/2 binary64) (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (sin.f64 re)))
(/.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (-.f64 (pow.f64 (exp.f64 im) #s(literal 6 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64)))) (.f64 #s(literal 2 binary64) (sinh.f64 (.f64 #s(literal 3 binary64) im))))
(/.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 9 binary64)) (pow.f64 (exp.f64 im) #s(literal 9 binary64)))) (+.f64 (expm1.f64 (.f64 (.f64 im #s(literal -3 binary64)) #s(literal 2 binary64))) (pow.f64 (exp.f64 im) #s(literal 6 binary64))))
(/.f64 (.f64 (-.f64 (pow.f64 (exp.f64 im) #s(literal 6 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 #s(literal 2 binary64) (sinh.f64 (.f64 #s(literal 3 binary64) im))))
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 9 binary64)) (pow.f64 (exp.f64 im) #s(literal 9 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (+.f64 (expm1.f64 (.f64 (.f64 im #s(literal -3 binary64)) #s(literal 2 binary64))) (pow.f64 (exp.f64 im) #s(literal 6 binary64))))
(fma.f64 (exp.f64 (.f64 im #s(literal -3 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (exp.f64 (.f64 im #s(literal -3 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (.f64 im #s(literal -3 binary64))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64))))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (.f64 im #s(literal -3 binary64)))))
(+.f64 (.f64 (exp.f64 (.f64 im #s(literal -3 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 (.f64 im #s(literal -3 binary64))) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (.f64 im #s(literal -3 binary64)))) (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64))))
(+.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (*.f64 im #s(literal -3 binary64)))))
(sin.f64 re)
(*.f64 (neg.f64 (sinh.f64 (neg.f64 im))) (neg.f64 (sinh.f64 (neg.f64 im))))
(*.f64 (neg.f64 (fabs.f64 (sinh.f64 im))) (neg.f64 (fabs.f64 (sinh.f64 im))))
(*.f64 (fabs.f64 (fabs.f64 (sinh.f64 im))) (fabs.f64 (fabs.f64 (sinh.f64 im))))
(*.f64 (pow.f64 (sinh.f64 im) #s(literal 1 binary64)) (pow.f64 (sinh.f64 im) #s(literal 1 binary64)))
(*.f64 (pow.f64 (sinh.f64 im) #s(literal 1 binary64)) (sinh.f64 im))
(*.f64 (sinh.f64 (neg.f64 im)) (sinh.f64 (neg.f64 im)))
(*.f64 (fabs.f64 (sinh.f64 im)) (fabs.f64 (sinh.f64 im)))
(*.f64 (sinh.f64 im) (sinh.f64 im))
(pow.f64 (sinh.f64 (neg.f64 im)) #s(literal 2 binary64))
(pow.f64 (fabs.f64 (sinh.f64 im)) #s(literal 2 binary64))
(pow.f64 (sinh.f64 im) #s(literal 2 binary64))
(/.f64 (.f64 (sinh.f64 im) (.f64 #s(literal 2 binary64) (sinh.f64 im))) #s(literal 2 binary64))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 im)) (sinh.f64 im)) #s(literal 2 binary64))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 im)) (*.f64 #s(literal 2 binary64) (sinh.f64 im))) #s(literal 4 binary64))
(neg.f64 (neg.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64))))
(fabs.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (sinh.f64 im)) #s(literal 2 binary64)))
(*.f64 #s(literal 2 binary64) (/.f64 (sinh.f64 im) #s(literal 2 binary64)))
(/.f64 (neg.f64 (*.f64 #s(literal 2 binary64) (sinh.f64 im))) #s(literal -2 binary64))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (.f64 #s(literal 2 binary64) (sinh.f64 im))) (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 2 binary64)))
(/.f64 (.f64 #s(literal 2 binary64) (sinh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) #s(literal -1 binary64))) #s(literal 2 binary64)))
(/.f64 (*.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 2 binary64))
(sinh.f64 im)
(-.f64 (/.f64 (exp.f64 im) #s(literal 2 binary64)) (/.f64 (exp.f64 (neg.f64 im)) #s(literal 2 binary64)))
(*.f64 (neg.f64 (neg.f64 (cosh.f64 im))) (neg.f64 (neg.f64 (cosh.f64 im))))
(*.f64 (neg.f64 (fabs.f64 (cosh.f64 im))) (neg.f64 (fabs.f64 (cosh.f64 im))))
(*.f64 (fabs.f64 (fabs.f64 (cosh.f64 im))) (fabs.f64 (fabs.f64 (cosh.f64 im))))
(*.f64 (pow.f64 (cosh.f64 im) #s(literal 1 binary64)) (pow.f64 (cosh.f64 im) #s(literal 1 binary64)))
(*.f64 (pow.f64 (cosh.f64 im) #s(literal 1 binary64)) (cosh.f64 im))
(*.f64 (neg.f64 (cosh.f64 im)) (neg.f64 (cosh.f64 im)))
(*.f64 (fabs.f64 (cosh.f64 im)) (fabs.f64 (cosh.f64 im)))
(*.f64 (cosh.f64 im) (cosh.f64 im))
(pow.f64 (neg.f64 (cosh.f64 im)) #s(literal 2 binary64))
(pow.f64 (fabs.f64 (cosh.f64 im)) #s(literal 2 binary64))
(pow.f64 (cosh.f64 im) #s(literal 2 binary64))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (cosh.f64 im)) #s(literal 2 binary64))
(/.f64 (.f64 (cosh.f64 im) (.f64 #s(literal 2 binary64) (cosh.f64 im))) #s(literal 2 binary64))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (*.f64 #s(literal 2 binary64) (cosh.f64 im))) #s(literal 4 binary64))
(neg.f64 (*.f64 (neg.f64 (cosh.f64 im)) (cosh.f64 im)))
(neg.f64 (*.f64 (cosh.f64 im) (neg.f64 (cosh.f64 im))))
(fabs.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (cosh.f64 im)) #s(literal 2 binary64)))
(.f64 (/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (.f64 #s(literal 2 binary64) (sinh.f64 im))) (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64)))) (-.f64 (exp.f64 (neg.f64 im)) (exp.f64 im)))
(.f64 (/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (.f64 #s(literal 2 binary64) (sinh.f64 im))) (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im)))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))
(*.f64 #s(literal 2 binary64) (sinh.f64 im))
(*.f64 (sinh.f64 im) #s(literal 2 binary64))
(/.f64 (/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (*.f64 #s(literal 2 binary64) (sinh.f64 im))) #s(literal 2 binary64)) (cosh.f64 im))
(/.f64 (/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (*.f64 #s(literal 2 binary64) (sinh.f64 im))) (cosh.f64 im)) #s(literal 2 binary64))
(/.f64 (neg.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (.f64 #s(literal 2 binary64) (sinh.f64 im)))) (neg.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im))))
(/.f64 (neg.f64 (.f64 #s(literal 2 binary64) (sinh.f64 (.f64 #s(literal 3 binary64) im)))) (neg.f64 (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) #s(literal -1 binary64)))))
(/.f64 (.f64 #s(literal 2 binary64) (.f64 #s(literal 2 binary64) (sinh.f64 im))) #s(literal 2 binary64))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (.f64 #s(literal 2 binary64) (sinh.f64 im))) (.f64 #s(literal 2 binary64) (cosh.f64 im)))
(/.f64 (.f64 #s(literal 2 binary64) (sinh.f64 (.f64 #s(literal 3 binary64) im))) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) #s(literal -1 binary64))))
(fma.f64 #s(literal 2 binary64) (/.f64 (sinh.f64 im) #s(literal 2 binary64)) (sinh.f64 im))
(fma.f64 #s(literal 2 binary64) (/.f64 (cosh.f64 im) #s(literal 2 binary64)) (-.f64 (sinh.f64 im) (exp.f64 (neg.f64 im))))
(fma.f64 (cosh.f64 im) #s(literal 1 binary64) (-.f64 (sinh.f64 im) (exp.f64 (neg.f64 im))))
(-.f64 (-.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 (neg.f64 im)))
(-.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (.f64 #s(literal 2 binary64) (cosh.f64 im))) (/.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
(-.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) #s(literal -1 binary64)))) (/.f64 (exp.f64 (.f64 im #s(literal -3 binary64))) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) #s(literal -1 binary64)))))
(-.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(+.f64 (-.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 im))
(+.f64 (sinh.f64 im) (sinh.f64 im))
(+.f64 (cosh.f64 im) (-.f64 (sinh.f64 im) (exp.f64 (neg.f64 im))))
(*.f64 (neg.f64 (pow.f64 (exp.f64 im) #s(literal 3/2 binary64))) (neg.f64 (pow.f64 (exp.f64 im) #s(literal 3/2 binary64))))
(*.f64 (fabs.f64 (pow.f64 (exp.f64 im) #s(literal 3/2 binary64))) (fabs.f64 (pow.f64 (exp.f64 im) #s(literal 3/2 binary64))))
(*.f64 (pow.f64 (exp.f64 im) #s(literal 3/2 binary64)) (pow.f64 (exp.f64 im) #s(literal 3/2 binary64)))
(*.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (exp.f64 im))
(*.f64 (exp.f64 im) (pow.f64 (exp.f64 im) #s(literal 2 binary64)))
(pow.f64 (pow.f64 (exp.f64 im) #s(literal 3/2 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) #s(literal 3/2 binary64))
(pow.f64 (exp.f64 im) #s(literal 3 binary64))
(/.f64 #s(literal -1 binary64) (pow.f64 (/.f64 #s(literal -1 binary64) (exp.f64 im)) #s(literal 3 binary64)))
(/.f64 #s(literal 1 binary64) (exp.f64 (*.f64 im #s(literal -3 binary64))))
(fma.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (cosh.f64 im) (*.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (sinh.f64 im)))
(fma.f64 (cosh.f64 im) (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (*.f64 (sinh.f64 im) (pow.f64 (exp.f64 im) #s(literal 2 binary64))))
(exp.f64 (*.f64 #s(literal 3 binary64) im))
(+.f64 (.f64 (cosh.f64 im) (pow.f64 (exp.f64 im) #s(literal 2 binary64))) (.f64 (sinh.f64 im) (pow.f64 (exp.f64 im) #s(literal 2 binary64))))
(+.f64 (.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (cosh.f64 im)) (.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (sinh.f64 im)))
(+.f64 (cosh.f64 (.f64 #s(literal 3 binary64) im)) (sinh.f64 (.f64 #s(literal 3 binary64) im)))
(/.f64 (-.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 4 binary64)) (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64))) (-.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (expm1.f64 (+.f64 im im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 4 binary64)))) (neg.f64 (-.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 3 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64)))) (neg.f64 (fma.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (expm1.f64 (+.f64 im im))) (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 4 binary64))) (-.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))
(/.f64 (+.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 3 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64))) (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 4 binary64)) (-.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 im)) (exp.f64 (neg.f64 im))))))
(/.f64 (+.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 3 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64))) (fma.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (expm1.f64 (+.f64 im im))) (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64))))
(fma.f64 (.f64 (exp.f64 im) #s(literal 2 binary64)) (sinh.f64 im) (exp.f64 (.f64 im #s(literal -2 binary64))))
(fma.f64 (fabs.f64 (exp.f64 (neg.f64 im))) (fabs.f64 (exp.f64 (neg.f64 im))) (expm1.f64 (+.f64 im im)))
(fma.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 1 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 1 binary64)) (expm1.f64 (+.f64 im im)))
(fma.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 1 binary64)) (exp.f64 (neg.f64 im)) (expm1.f64 (+.f64 im im)))
(fma.f64 (/.f64 #s(literal -1 binary64) (exp.f64 im)) (/.f64 #s(literal -1 binary64) (exp.f64 im)) (expm1.f64 (+.f64 im im)))
(fma.f64 (.f64 #s(literal 2 binary64) (sinh.f64 im)) (exp.f64 im) (exp.f64 (.f64 im #s(literal -2 binary64))))
(fma.f64 (exp.f64 im) (.f64 #s(literal 2 binary64) (sinh.f64 im)) (exp.f64 (.f64 im #s(literal -2 binary64))))
(fma.f64 #s(literal 2 binary64) (.f64 (sinh.f64 im) (exp.f64 im)) (exp.f64 (.f64 im #s(literal -2 binary64))))
(fma.f64 (exp.f64 (neg.f64 im)) (exp.f64 (neg.f64 im)) (expm1.f64 (+.f64 im im)))
(-.f64 (+.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (pow.f64 (exp.f64 im) #s(literal 2 binary64))) #s(literal 1 binary64))
(-.f64 (/.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64)) (-.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))) (/.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 4 binary64)) (-.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (.f64 im #s(literal -2 binary64))))))
(-.f64 (expm1.f64 (+.f64 im im)) (*.f64 (/.f64 #s(literal -1 binary64) (exp.f64 im)) (exp.f64 (neg.f64 im))))
(-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (.f64 (neg.f64 (*.f64 #s(literal 2 binary64) (sinh.f64 im))) (exp.f64 im)))
(-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (.f64 (neg.f64 (exp.f64 im)) (*.f64 #s(literal 2 binary64) (sinh.f64 im))))
(+.f64 (+.f64 (expm1.f64 (+.f64 im im)) (cosh.f64 (+.f64 im im))) (sinh.f64 (*.f64 im #s(literal -2 binary64))))
(+.f64 (/.f64 (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 3 binary64)) (fma.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (expm1.f64 (+.f64 im im))) (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64)))) (/.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 6 binary64)) (fma.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (-.f64 (exp.f64 (.f64 im #s(literal -2 binary64))) (expm1.f64 (+.f64 im im))) (pow.f64 (expm1.f64 (+.f64 im im)) #s(literal 2 binary64)))))
(+.f64 (cosh.f64 (+.f64 im im)) (+.f64 (sinh.f64 (*.f64 im #s(literal -2 binary64))) (expm1.f64 (+.f64 im im))))
(+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64))))
(+.f64 (exp.f64 (*.f64 im #s(literal -2 binary64))) (expm1.f64 (+.f64 im im)))

eval62.0ms (0.9%)

Memory: 10.8MiB live, 156.5MiB allocated; 9ms collecting garbage
Compiler: Compiled 15 263 to 2 098 computations (86.3% saved)

prune17.0ms (0.2%)

Memory

4.0MiB live, 51.4MiB allocated; 2ms collecting garbage

Pruning

13 alts after pruning (12 fresh and 1 done)

	Pruned	Kept	Total
New	509	12	521
Fresh	0	0	0
Picked	3	1	4
Done	0	0	0
Total	512	13	525

Accuracy

100.0%

Counts

525 → 13

Alt Table

Click to see full alt table

Status	Accuracy	Program
	55.9%	(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))
	62.7%	(.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (*.f64 re re) #s(literal 1 binary64)) re))) #s(literal 1/2 binary64))
▶	100.0%	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)))))
	91.4%	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))
	88.0%	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 #s(literal 1/12 binary64) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64))))
✓	76.3%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re)))
▶	51.8%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (fma.f64 (.f64 re (.f64 re re)) (-.f64 (.f64 (.f64 (fma.f64 #s(literal -1/5040 binary64) (*.f64 re re) #s(literal 1/120 binary64)) re) re) #s(literal 1/6 binary64)) re))))
	55.1%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (.f64 (fma.f64 (-.f64 (.f64 #s(literal 1/120 binary64) (.f64 re re)) #s(literal 1/6 binary64)) (.f64 re re) #s(literal 1 binary64)) re))))
	50.8%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re))))
	56.0%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 #s(approx (+ ( (* 1/2 im) im) 1) #s(literal 1 binary64)) (sin.f64 re)))
▶	36.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
▶	52.2%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)))
▶	18.5%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) im) im)))

Compiler

Compiled 770 to 554 computations (28.1% saved)

simplify105.0ms (1.5%)

Memory

15.3MiB live, 160.5MiB allocated; 21ms collecting garbage

Localize:

Found 20 expressions of interest:

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

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	58	499
0	95	478
1	185	472
2	509	472
3	1820	472
0	8310	472

Stop Event

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

Calls

Call 1

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

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

localize180.0ms (2.6%)

Memory

-1.9MiB live, 238.4MiB allocated; 16ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.0546875	(.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) im) im)
accuracy	0.05859375	(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) im)
accuracy	0.8895000611818431	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) im) im)))
accuracy	34.051902259952016	#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) im) im))
accuracy	0.05859375	(.f64 (.f64 (fma.f64 #s(literal -1/5040 binary64) (*.f64 re re) #s(literal 1/120 binary64)) re) re)
accuracy	0.0703125	(.f64 (fma.f64 #s(literal -1/5040 binary64) (.f64 re re) #s(literal 1/120 binary64)) re)
accuracy	0.8895000611818431	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (fma.f64 (.f64 re (.f64 re re)) (-.f64 (.f64 (.f64 (fma.f64 #s(literal -1/5040 binary64) (*.f64 re re) #s(literal 1/120 binary64)) re) re) #s(literal 1/6 binary64)) re))))
accuracy	15.450307627502948	#s(approx (sin re) (fma.f64 (.f64 re (.f64 re re)) (-.f64 (.f64 (.f64 (fma.f64 #s(literal -1/5040 binary64) (*.f64 re re) #s(literal 1/120 binary64)) re) re) #s(literal 1/6 binary64)) re))
accuracy	0.03125	(fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)))
accuracy	0.18359375	(.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)
accuracy	0.8895000611818431	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
accuracy	15.608225427409614	#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re))
accuracy	0.0	(*.f64 im im)
accuracy	0.00390625	(.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)
accuracy	0.8895000611818431	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)))
accuracy	15.583431049655063	#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
accuracy	0.0	(exp.f64 (neg.f64 im))
accuracy	0.00390625	(/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)))
accuracy	0.00390625	(sin.f64 re)
accuracy	0.0078125	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)))))

Samples

77.0ms	145×	0	valid
71.0ms	111×	0	exit

Compiler

Compiled 349 to 50 computations (85.7% saved)

Precisions

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

ival-mult: 53.0ms (58% of total)

const: 14.0ms (15.3% of total)

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

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

ival-exp: 5.0ms (5.5% of total)

ival-sub: 2.0ms (2.2% of total)

ival-div: 1.0ms (1.1% of total)

ival-neg: 1.0ms (1.1% of total)

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

series57.0ms (0.8%)

Memory

-40.8MiB live, 56.0MiB allocated; 9ms collecting garbage

Counts

27 → 88

Calls

Call 1

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

Outputs
(* 1/2 (* re (+ (exp (neg im)) (/ 1 (exp (neg im))))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp (neg im)) (/ 1 (exp (neg im)))))) (* 1/2 (+ (exp (neg im)) (/ 1 (exp (neg im)))))))
(* re (+ (* 1/2 (+ (exp (neg im)) (/ 1 (exp (neg im))))) (* (pow re 2) (+ (* -1/12 (+ (exp (neg im)) (/ 1 (exp (neg im))))) (* 1/240 (* (pow re 2) (+ (exp (neg im)) (/ 1 (exp (neg im))))))))))
(* re (+ (* 1/2 (+ (exp (neg im)) (/ 1 (exp (neg im))))) (* (pow re 2) (+ (* -1/12 (+ (exp (neg im)) (/ 1 (exp (neg im))))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp (neg im)) (/ 1 (exp (neg im)))))) (* 1/240 (+ (exp (neg im)) (/ 1 (exp (neg im)))))))))))
(* 1/2 re)
(* re (+ 1/2 (* -1/12 (pow re 2))))
(* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))
(* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))
(* 1/2 (* re (+ (exp im) (exp (neg im)))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* 1/240 (* (pow re 2) (+ (exp im) (exp (neg im)))))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/240 (+ (exp im) (exp (neg im))))))))))
(* re (+ 1 (* 1/2 (pow im 2))))
(* re (+ 1 (+ (* -1/6 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/2 (pow im 2)))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* 1/120 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))))))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/120 (+ 1 (* 1/2 (pow im 2)))))))))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (- (* -1/12 (pow im 2)) 1/6)))))
(+ 1 (* 1/2 (pow im 2)))
(+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (- (* -1/12 (pow im 2)) 1/6))))
(pow re 3)
(* 1/2 (* (pow im 2) re))
(* re (+ (* -1/12 (* (pow im 2) (pow re 2))) (* 1/2 (pow im 2))))
(* re (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/12 (pow im 2)) (* 1/240 (* (pow im 2) (pow re 2)))))))
(* re (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/12 (pow im 2)) (* (pow re 2) (+ (* -1/10080 (* (pow im 2) (pow re 2))) (* 1/240 (pow im 2))))))))
(* 1/2 (* im re))
(* re (+ (* -1/12 (* im (pow re 2))) (* 1/2 im)))
(* re (+ (* 1/2 im) (* (pow re 2) (+ (* -1/12 im) (* 1/240 (* im (pow re 2)))))))
(* re (+ (* 1/2 im) (* (pow re 2) (+ (* -1/12 im) (* (pow re 2) (+ (* -1/10080 (* im (pow re 2))) (* 1/240 im)))))))
re
(* re (+ 1 (* -1/6 (pow re 2))))
(* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))
(* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))
(* re (- (* -1/12 (pow im 2)) 1/6))
(* 1/120 re)
(* re (+ 1/120 (* -1/5040 (pow re 2))))
(* 1/120 (pow re 2))
(* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2))))
(* 1/2 (* (sin re) (+ (exp (neg im)) (/ 1 (exp (neg im))))))
(* 1/2 (sin re))
(* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))
(* (sin re) (+ 1 (* 1/2 (pow im 2))))
(* (pow re 3) (- (* -1/12 (pow im 2)) 1/6))
(* (pow re 3) (- (+ (* -1/12 (pow im 2)) (+ (* 1/2 (/ (pow im 2) (pow re 2))) (/ 1 (pow re 2)))) 1/6))
(* (pow re 2) (- (* -1/12 (pow im 2)) 1/6))
(* (pow re 2) (- (+ (* -1/12 (pow im 2)) (+ (* 1/2 (/ (pow im 2) (pow re 2))) (/ 1 (pow re 2)))) 1/6))
(* 1/2 (* (pow im 2) (sin re)))
(* 1/2 (* im (sin re)))
(sin re)
(* -1/5040 (pow re 3))
(* (pow re 3) (- (* 1/120 (/ 1 (pow re 2))) 1/5040))
(* -1/5040 (pow re 4))
(* (pow re 4) (- (* 1/120 (/ 1 (pow re 2))) 1/5040))
(* -1 (* (pow re 3) (+ (* -1 (- (* -1/12 (pow im 2)) 1/6)) (* -1 (/ (+ 1 (* 1/2 (pow im 2))) (pow re 2))))))
(* -1 (* (pow re 3) (- 1/5040 (* 1/120 (/ 1 (pow re 2))))))
1
(+ 1 im)
(+ 1 (* im (+ 1 (* 1/2 im))))
(+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))
(* -1 im)
(+ (sin re) (* 1/2 (* (pow im 2) (sin re))))
(+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))
(+ re (* 1/2 (* (pow im 2) re)))
(+ (* re (+ 1 (* -1/6 (pow re 2)))) (* (pow im 2) (* re (+ 1/2 (* -1/12 (pow re 2))))))
(+ 1 (* -1/6 (pow re 2)))
(+ 1 (+ (* -1/6 (pow re 2)) (* (pow im 2) (+ 1/2 (* -1/12 (pow re 2))))))
(+ 1 (* -1 im))
(+ 1 (* im (- (* 1/2 im) 1)))
(+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))
(pow im 2)
(* -1/6 re)
(+ (* -1/6 re) (* -1/12 (* (pow im 2) re)))
(/ 1 (exp (neg im)))
(* (pow im 2) (+ (* 1/2 (sin re)) (/ (sin re) (pow im 2))))
(* (pow im 2) (+ (* 1/2 re) (/ re (pow im 2))))
(* 1/2 (pow im 2))
(* (pow im 2) (+ 1/2 (/ 1 (pow im 2))))
(* (pow im 2) (* re (+ 1/2 (* -1/12 (pow re 2)))))
(* (pow im 2) (+ (* re (+ 1/2 (* -1/12 (pow re 2)))) (/ (* re (+ 1 (* -1/6 (pow re 2)))) (pow im 2))))
(* (pow im 2) (+ 1/2 (* -1/12 (pow re 2))))
(* (pow im 2) (+ 1/2 (+ (* -1/6 (/ (pow re 2) (pow im 2))) (+ (* -1/12 (pow re 2)) (/ 1 (pow im 2))))))
(exp (neg im))
(* -1/12 (* (pow im 2) re))
(* (pow im 2) (+ (* -1/6 (/ re (pow im 2))) (* -1/12 re)))
(/ 1 (exp (* -1 im)))
(* 1/2 (* (sin re) (+ (exp (* -1 im)) (/ 1 (exp (* -1 im))))))
(* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))
(exp (* -1 im))

Calls

6 calls:

Time	Variable		Point	Expression
21.0ms	re	@	0	((/ 1 (exp (neg im))) (- 0 im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ 1 (exp (neg im))))) (* 1/2 (sin re)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* im im) 1/2) 1) re) (+ (* (* im im) 1/2) 1) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* re (* re re)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* (* 1/2 im) im) 1) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (* (* (sin re) 1/2) im) im) (* (* (sin re) 1/2) im) (sin re) (exp (neg im)) (* im im) (* (+ (* (* im im) -1/12) -1/6) re) (sin re) (* (+ (* -1/5040 (* re re)) 1/120) re) (* (* (+ (* -1/5040 (* re re)) 1/120) re) re))
6.0ms	re	@	-inf	((/ 1 (exp (neg im))) (- 0 im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ 1 (exp (neg im))))) (* 1/2 (sin re)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* im im) 1/2) 1) re) (+ (* (* im im) 1/2) 1) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* re (* re re)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* (* 1/2 im) im) 1) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (* (* (sin re) 1/2) im) im) (* (* (sin re) 1/2) im) (sin re) (exp (neg im)) (* im im) (* (+ (* (* im im) -1/12) -1/6) re) (sin re) (* (+ (* -1/5040 (* re re)) 1/120) re) (* (* (+ (* -1/5040 (* re re)) 1/120) re) re))
6.0ms	re	@	inf	((/ 1 (exp (neg im))) (- 0 im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ 1 (exp (neg im))))) (* 1/2 (sin re)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* im im) 1/2) 1) re) (+ (* (* im im) 1/2) 1) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* re (* re re)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* (* 1/2 im) im) 1) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (* (* (sin re) 1/2) im) im) (* (* (sin re) 1/2) im) (sin re) (exp (neg im)) (* im im) (* (+ (* (* im im) -1/12) -1/6) re) (sin re) (* (+ (* -1/5040 (* re re)) 1/120) re) (* (* (+ (* -1/5040 (* re re)) 1/120) re) re))
5.0ms	im	@	inf	((/ 1 (exp (neg im))) (- 0 im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ 1 (exp (neg im))))) (* 1/2 (sin re)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* im im) 1/2) 1) re) (+ (* (* im im) 1/2) 1) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* re (* re re)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* (* 1/2 im) im) 1) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (* (* (sin re) 1/2) im) im) (* (* (sin re) 1/2) im) (sin re) (exp (neg im)) (* im im) (* (+ (* (* im im) -1/12) -1/6) re) (sin re) (* (+ (* -1/5040 (* re re)) 1/120) re) (* (* (+ (* -1/5040 (* re re)) 1/120) re) re))
4.0ms	im	@	-inf	((/ 1 (exp (neg im))) (- 0 im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ 1 (exp (neg im))))) (* 1/2 (sin re)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* im im) 1/2) 1) re) (+ (* (* im im) 1/2) 1) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* re (* re re)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* (* 1/2 im) im) 1) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (* (* (sin re) 1/2) im) im) (* (* (sin re) 1/2) im) (sin re) (exp (neg im)) (* im im) (* (+ (* (* im im) -1/12) -1/6) re) (sin re) (* (+ (* -1/5040 (* re re)) 1/120) re) (* (* (+ (* -1/5040 (* re re)) 1/120) re) re))

simplify146.0ms (2.1%)

Memory

26.5MiB live, 258.9MiB allocated; 23ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	282	1296
1	1118	1145
2	5234	1128
0	8343	1025

Stop Event

1×	iter limit
1×	node limit

Counts

88 → 87

Calls

Call 1

Inputs
(* 1/2 (* re (+ (exp (neg im)) (/ 1 (exp (neg im))))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp (neg im)) (/ 1 (exp (neg im)))))) (* 1/2 (+ (exp (neg im)) (/ 1 (exp (neg im)))))))
(* re (+ (* 1/2 (+ (exp (neg im)) (/ 1 (exp (neg im))))) (* (pow re 2) (+ (* -1/12 (+ (exp (neg im)) (/ 1 (exp (neg im))))) (* 1/240 (* (pow re 2) (+ (exp (neg im)) (/ 1 (exp (neg im))))))))))
(* re (+ (* 1/2 (+ (exp (neg im)) (/ 1 (exp (neg im))))) (* (pow re 2) (+ (* -1/12 (+ (exp (neg im)) (/ 1 (exp (neg im))))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp (neg im)) (/ 1 (exp (neg im)))))) (* 1/240 (+ (exp (neg im)) (/ 1 (exp (neg im)))))))))))
(* 1/2 re)
(* re (+ 1/2 (* -1/12 (pow re 2))))
(* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))
(* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))
(* 1/2 (* re (+ (exp im) (exp (neg im)))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* 1/240 (* (pow re 2) (+ (exp im) (exp (neg im)))))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/240 (+ (exp im) (exp (neg im))))))))))
(* re (+ 1 (* 1/2 (pow im 2))))
(* re (+ 1 (+ (* -1/6 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/2 (pow im 2)))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* 1/120 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))))))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/120 (+ 1 (* 1/2 (pow im 2)))))))))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (- (* -1/12 (pow im 2)) 1/6)))))
(+ 1 (* 1/2 (pow im 2)))
(+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (- (* -1/12 (pow im 2)) 1/6))))
(pow re 3)
(* 1/2 (* (pow im 2) re))
(* re (+ (* -1/12 (* (pow im 2) (pow re 2))) (* 1/2 (pow im 2))))
(* re (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/12 (pow im 2)) (* 1/240 (* (pow im 2) (pow re 2)))))))
(* re (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/12 (pow im 2)) (* (pow re 2) (+ (* -1/10080 (* (pow im 2) (pow re 2))) (* 1/240 (pow im 2))))))))
(* 1/2 (* im re))
(* re (+ (* -1/12 (* im (pow re 2))) (* 1/2 im)))
(* re (+ (* 1/2 im) (* (pow re 2) (+ (* -1/12 im) (* 1/240 (* im (pow re 2)))))))
(* re (+ (* 1/2 im) (* (pow re 2) (+ (* -1/12 im) (* (pow re 2) (+ (* -1/10080 (* im (pow re 2))) (* 1/240 im)))))))
re
(* re (+ 1 (* -1/6 (pow re 2))))
(* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))
(* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))
(* re (- (* -1/12 (pow im 2)) 1/6))
(* 1/120 re)
(* re (+ 1/120 (* -1/5040 (pow re 2))))
(* 1/120 (pow re 2))
(* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2))))
(* 1/2 (* (sin re) (+ (exp (neg im)) (/ 1 (exp (neg im))))))
(* 1/2 (sin re))
(* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))
(* (sin re) (+ 1 (* 1/2 (pow im 2))))
(* (pow re 3) (- (* -1/12 (pow im 2)) 1/6))
(* (pow re 3) (- (+ (* -1/12 (pow im 2)) (+ (* 1/2 (/ (pow im 2) (pow re 2))) (/ 1 (pow re 2)))) 1/6))
(* (pow re 2) (- (* -1/12 (pow im 2)) 1/6))
(* (pow re 2) (- (+ (* -1/12 (pow im 2)) (+ (* 1/2 (/ (pow im 2) (pow re 2))) (/ 1 (pow re 2)))) 1/6))
(* 1/2 (* (pow im 2) (sin re)))
(* 1/2 (* im (sin re)))
(sin re)
(* -1/5040 (pow re 3))
(* (pow re 3) (- (* 1/120 (/ 1 (pow re 2))) 1/5040))
(* -1/5040 (pow re 4))
(* (pow re 4) (- (* 1/120 (/ 1 (pow re 2))) 1/5040))
(* -1 (* (pow re 3) (+ (* -1 (- (* -1/12 (pow im 2)) 1/6)) (* -1 (/ (+ 1 (* 1/2 (pow im 2))) (pow re 2))))))
(* -1 (* (pow re 3) (- 1/5040 (* 1/120 (/ 1 (pow re 2))))))
1
(+ 1 im)
(+ 1 (* im (+ 1 (* 1/2 im))))
(+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))
(* -1 im)
(+ (sin re) (* 1/2 (* (pow im 2) (sin re))))
(+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))
(+ re (* 1/2 (* (pow im 2) re)))
(+ (* re (+ 1 (* -1/6 (pow re 2)))) (* (pow im 2) (* re (+ 1/2 (* -1/12 (pow re 2))))))
(+ 1 (* -1/6 (pow re 2)))
(+ 1 (+ (* -1/6 (pow re 2)) (* (pow im 2) (+ 1/2 (* -1/12 (pow re 2))))))
(+ 1 (* -1 im))
(+ 1 (* im (- (* 1/2 im) 1)))
(+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))
(pow im 2)
(* -1/6 re)
(+ (* -1/6 re) (* -1/12 (* (pow im 2) re)))
(/ 1 (exp (neg im)))
(* (pow im 2) (+ (* 1/2 (sin re)) (/ (sin re) (pow im 2))))
(* (pow im 2) (+ (* 1/2 re) (/ re (pow im 2))))
(* 1/2 (pow im 2))
(* (pow im 2) (+ 1/2 (/ 1 (pow im 2))))
(* (pow im 2) (* re (+ 1/2 (* -1/12 (pow re 2)))))
(* (pow im 2) (+ (* re (+ 1/2 (* -1/12 (pow re 2)))) (/ (* re (+ 1 (* -1/6 (pow re 2)))) (pow im 2))))
(* (pow im 2) (+ 1/2 (* -1/12 (pow re 2))))
(* (pow im 2) (+ 1/2 (+ (* -1/6 (/ (pow re 2) (pow im 2))) (+ (* -1/12 (pow re 2)) (/ 1 (pow im 2))))))
(exp (neg im))
(* -1/12 (* (pow im 2) re))
(* (pow im 2) (+ (* -1/6 (/ re (pow im 2))) (* -1/12 re)))
(/ 1 (exp (* -1 im)))
(* 1/2 (* (sin re) (+ (exp (* -1 im)) (/ 1 (exp (* -1 im))))))
(* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))
(exp (* -1 im))

Outputs
(* 1/2 (* re (+ (exp (neg im)) (/ 1 (exp (neg im))))))
(.f64 (.f64 #s(literal 1/2 binary64) re) (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp (neg im)) (/ 1 (exp (neg im)))))) (* 1/2 (+ (exp (neg im)) (/ 1 (exp (neg im)))))))
(.f64 (.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64))) re)
(* re (+ (* 1/2 (+ (exp (neg im)) (/ 1 (exp (neg im))))) (* (pow re 2) (+ (* -1/12 (+ (exp (neg im)) (/ 1 (exp (neg im))))) (* 1/240 (* (pow re 2) (+ (exp (neg im)) (/ 1 (exp (neg im))))))))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) re) (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))))
(* re (+ (* 1/2 (+ (exp (neg im)) (/ 1 (exp (neg im))))) (* (pow re 2) (+ (* -1/12 (+ (exp (neg im)) (/ 1 (exp (neg im))))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp (neg im)) (/ 1 (exp (neg im)))))) (* 1/240 (+ (exp (neg im)) (/ 1 (exp (neg im)))))))))))
(.f64 (fma.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (fma.f64 #s(literal -1/10080 binary64) (*.f64 re re) #s(literal 1/240 binary64))))) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* re (+ 1/2 (* -1/12 (pow re 2))))
(.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)
(* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))
(.f64 (fma.f64 (-.f64 (.f64 #s(literal 1/240 binary64) (.f64 re re)) #s(literal 1/12 binary64)) (.f64 re re) #s(literal 1/2 binary64)) re)
(* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (-.f64 (.f64 (.f64 (fma.f64 #s(literal -1/10080 binary64) (.f64 re re) #s(literal 1/240 binary64)) re) re) #s(literal 1/12 binary64)) (.f64 #s(literal 1/2 binary64) re))
(* 1/2 (* re (+ (exp im) (exp (neg im)))))
(.f64 (.f64 #s(literal 1/2 binary64) re) (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))
(.f64 (.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64))) re)
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* 1/240 (* (pow re 2) (+ (exp im) (exp (neg im)))))))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) re) (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/240 (+ (exp im) (exp (neg im))))))))))
(.f64 (fma.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (fma.f64 #s(literal -1/10080 binary64) (*.f64 re re) #s(literal 1/240 binary64))))) re)
(* re (+ 1 (* 1/2 (pow im 2))))
(.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)
(* re (+ 1 (+ (* -1/6 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/2 (pow im 2)))))
(.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* 1/120 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))))))))
(.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 #s(literal 1/120 binary64) (.f64 re re) #s(literal -1/6 binary64))) (.f64 re re) (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/120 (+ 1 (* 1/2 (pow im 2)))))))))))
(.f64 (fma.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 #s(literal -1/5040 binary64) (.f64 re re) #s(literal 1/120 binary64))) (.f64 re re) (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64))) (.f64 re re) (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (- (* -1/12 (pow im 2)) 1/6)))))
(.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(+ 1 (* 1/2 (pow im 2)))
(fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))
(+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (- (* -1/12 (pow im 2)) 1/6))))
(fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)))
(pow re 3)
(pow.f64 re #s(literal 3 binary64))
(* 1/2 (* (pow im 2) re))
(.f64 (.f64 (*.f64 im im) re) #s(literal 1/2 binary64))
(* re (+ (* -1/12 (* (pow im 2) (pow re 2))) (* 1/2 (pow im 2))))
(.f64 (.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re) im) im)
(* re (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/12 (pow im 2)) (* 1/240 (* (pow im 2) (pow re 2)))))))
(.f64 (fma.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im (.f64 (.f64 (.f64 im im) #s(literal 1/240 binary64)) (pow.f64 re #s(literal 4 binary64)))) re)
(* re (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/12 (pow im 2)) (* (pow re 2) (+ (* -1/10080 (* (pow im 2) (pow re 2))) (* 1/240 (pow im 2))))))))
(.f64 (fma.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im (.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 (.f64 (.f64 im im) re) re) #s(literal -1/10080 binary64) (.f64 (*.f64 im im) #s(literal 1/240 binary64))))) re)
(* 1/2 (* im re))
(.f64 (.f64 re im) #s(literal 1/2 binary64))
(* re (+ (* -1/12 (* im (pow re 2))) (* 1/2 im)))
(.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal -1/12 binary64) (.f64 #s(literal 1/2 binary64) im)) re)
(* re (+ (* 1/2 im) (* (pow re 2) (+ (* -1/12 im) (* 1/240 (* im (pow re 2)))))))
(fma.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal 1/240 binary64) (.f64 #s(literal -1/12 binary64) im)) (pow.f64 re #s(literal 3 binary64)) (.f64 (*.f64 re im) #s(literal 1/2 binary64)))
(* re (+ (* 1/2 im) (* (pow re 2) (+ (* -1/12 im) (* (pow re 2) (+ (* -1/10080 (* im (pow re 2))) (* 1/240 im)))))))
(fma.f64 (fma.f64 (.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal -1/10080 binary64) (.f64 #s(literal 1/240 binary64) im)) re) re (.f64 #s(literal -1/12 binary64) im)) (pow.f64 re #s(literal 3 binary64)) (.f64 (*.f64 re im) #s(literal 1/2 binary64)))
re
(* re (+ 1 (* -1/6 (pow re 2))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64) re)
(* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))
(fma.f64 (fma.f64 #s(literal 1/120 binary64) (*.f64 re re) #s(literal -1/6 binary64)) (pow.f64 re #s(literal 3 binary64)) re)
(* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))
(fma.f64 (fma.f64 (fma.f64 #s(literal -1/5040 binary64) (.f64 re re) #s(literal 1/120 binary64)) (.f64 re re) #s(literal -1/6 binary64)) (pow.f64 re #s(literal 3 binary64)) re)
(* re (- (* -1/12 (pow im 2)) 1/6))
(.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)
(* 1/120 re)
(*.f64 #s(literal 1/120 binary64) re)
(* re (+ 1/120 (* -1/5040 (pow re 2))))
(.f64 (fma.f64 #s(literal -1/5040 binary64) (.f64 re re) #s(literal 1/120 binary64)) re)
(* 1/120 (pow re 2))
(.f64 #s(literal 1/120 binary64) (.f64 re re))
(* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2))))
(.f64 (.f64 (fma.f64 #s(literal -1/5040 binary64) (*.f64 re re) #s(literal 1/120 binary64)) re) re)
(* 1/2 (* (sin re) (+ (exp (neg im)) (/ 1 (exp (neg im))))))
(*.f64 (fma.f64 (exp.f64 im) #s(literal 1/2 binary64) (/.f64 #s(literal 1/2 binary64) (exp.f64 im))) (sin.f64 re))
(* 1/2 (sin re))
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
(* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))
(*.f64 (fma.f64 (exp.f64 im) #s(literal 1/2 binary64) (/.f64 #s(literal 1/2 binary64) (exp.f64 im))) (sin.f64 re))
(* (sin re) (+ 1 (* 1/2 (pow im 2))))
(.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (sin.f64 re))
(* (pow re 3) (- (* -1/12 (pow im 2)) 1/6))
(.f64 (pow.f64 re #s(literal 3 binary64)) (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)))
(* (pow re 3) (- (+ (* -1/12 (pow im 2)) (+ (* 1/2 (/ (pow im 2) (pow re 2))) (/ 1 (pow re 2)))) 1/6))
(.f64 (-.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) im) im (/.f64 (/.f64 (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re) re)) #s(literal 1/6 binary64)) (pow.f64 re #s(literal 3 binary64)))
(* (pow re 2) (- (* -1/12 (pow im 2)) 1/6))
(.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)
(* (pow re 2) (- (+ (* -1/12 (pow im 2)) (+ (* 1/2 (/ (pow im 2) (pow re 2))) (/ 1 (pow re 2)))) 1/6))
(.f64 (-.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) im) im (/.f64 (/.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re) re)) #s(literal 1/6 binary64)) (.f64 re re))
(* 1/2 (* (pow im 2) (sin re)))
(.f64 (.f64 (*.f64 (sin.f64 re) im) #s(literal 1/2 binary64)) im)
(* 1/2 (* im (sin re)))
(.f64 (.f64 (sin.f64 re) im) #s(literal 1/2 binary64))
(sin re)
(sin.f64 re)
(* -1/5040 (pow re 3))
(*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/5040 binary64))
(* (pow re 3) (- (* 1/120 (/ 1 (pow re 2))) 1/5040))
(.f64 (-.f64 (/.f64 #s(literal 1/120 binary64) (.f64 re re)) #s(literal 1/5040 binary64)) (pow.f64 re #s(literal 3 binary64)))
(* -1/5040 (pow re 4))
(*.f64 (pow.f64 re #s(literal 4 binary64)) #s(literal -1/5040 binary64))
(* (pow re 4) (- (* 1/120 (/ 1 (pow re 2))) 1/5040))
(.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (/.f64 #s(literal 1/120 binary64) (.f64 re re)) #s(literal 1/5040 binary64)))
(* -1 (* (pow re 3) (+ (* -1 (- (* -1/12 (pow im 2)) 1/6)) (* -1 (/ (+ 1 (* 1/2 (pow im 2))) (pow re 2))))))
(.f64 (-.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) im) im (/.f64 (/.f64 (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re) re)) #s(literal 1/6 binary64)) (pow.f64 re #s(literal 3 binary64)))
(* -1 (* (pow re 3) (- 1/5040 (* 1/120 (/ 1 (pow re 2))))))
(.f64 (neg.f64 (-.f64 #s(literal 1/5040 binary64) (/.f64 #s(literal 1/120 binary64) (.f64 re re)))) (pow.f64 re #s(literal 3 binary64)))
1
#s(literal 1 binary64)
(+ 1 im)
(+.f64 #s(literal 1 binary64) im)
(+ 1 (* im (+ 1 (* 1/2 im))))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 1 binary64)) im #s(literal 1 binary64))
(+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/6 binary64) im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) im #s(literal 1 binary64))
(* -1 im)
(neg.f64 im)
(+ (sin re) (* 1/2 (* (pow im 2) (sin re))))
(.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (sin.f64 re))
(+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))
(fma.f64 (.f64 (sin.f64 re) (fma.f64 #s(literal 1/24 binary64) (.f64 im im) #s(literal 1/2 binary64))) (*.f64 im im) (sin.f64 re))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (sin.f64 re) (.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (sin.f64 re) (fma.f64 #s(literal 1/720 binary64) (.f64 im im) #s(literal 1/24 binary64)))))
(+ re (* 1/2 (* (pow im 2) re)))
(.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)
(+ (* re (+ 1 (* -1/6 (pow re 2)))) (* (pow im 2) (* re (+ 1/2 (* -1/12 (pow re 2))))))
(fma.f64 (.f64 (.f64 (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re) im) im (fma.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64) re))
(+ 1 (* -1/6 (pow re 2)))
(fma.f64 #s(literal -1/6 binary64) (*.f64 re re) #s(literal 1 binary64))
(+ 1 (+ (* -1/6 (pow re 2)) (* (pow im 2) (+ 1/2 (* -1/12 (pow re 2))))))
(fma.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im (fma.f64 #s(literal -1/6 binary64) (*.f64 re re) #s(literal 1 binary64)))
(+ 1 (* -1 im))
(-.f64 #s(literal 1 binary64) im)
(+ 1 (* im (- (* 1/2 im) 1)))
(fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal -1 binary64)) im #s(literal 1 binary64))
(+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))
(fma.f64 (fma.f64 (fma.f64 #s(literal -1/6 binary64) im #s(literal 1/2 binary64)) im #s(literal -1 binary64)) im #s(literal 1 binary64))
(pow im 2)
(*.f64 im im)
(* -1/6 re)
(*.f64 #s(literal -1/6 binary64) re)
(+ (* -1/6 re) (* -1/12 (* (pow im 2) re)))
(.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)
(/ 1 (exp (neg im)))
(exp.f64 im)
(* (pow im 2) (+ (* 1/2 (sin re)) (/ (sin re) (pow im 2))))
(.f64 (fma.f64 (sin.f64 re) #s(literal 1/2 binary64) (/.f64 (/.f64 (sin.f64 re) im) im)) (.f64 im im))
(* (pow im 2) (+ (* 1/2 re) (/ re (pow im 2))))
(.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) re (/.f64 re (*.f64 im im))) im) im)
(* 1/2 (pow im 2))
(.f64 (.f64 im im) #s(literal 1/2 binary64))
(* (pow im 2) (+ 1/2 (/ 1 (pow im 2))))
(fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))
(* (pow im 2) (* re (+ 1/2 (* -1/12 (pow re 2)))))
(.f64 (.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re) im) im)
(* (pow im 2) (+ (* re (+ 1/2 (* -1/12 (pow re 2)))) (/ (* re (+ 1 (* -1/6 (pow re 2)))) (pow im 2))))
(.f64 (fma.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re (/.f64 (/.f64 (fma.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64) re) im) im)) (*.f64 im im))
(* (pow im 2) (+ 1/2 (* -1/12 (pow re 2))))
(.f64 (.f64 (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im)
(* (pow im 2) (+ 1/2 (+ (* -1/6 (/ (pow re 2) (pow im 2))) (+ (* -1/12 (pow re 2)) (/ 1 (pow im 2))))))
(.f64 (+.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) re) re (/.f64 (/.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) im) im)) #s(literal 1/2 binary64)) (.f64 im im))
(exp (neg im))
(exp.f64 (neg.f64 im))
(* -1/12 (* (pow im 2) re))
(.f64 (.f64 (*.f64 im im) re) #s(literal -1/12 binary64))
(* (pow im 2) (+ (* -1/6 (/ re (pow im 2))) (* -1/12 re)))
(.f64 (.f64 (fma.f64 (/.f64 re (.f64 im im)) #s(literal -1/6 binary64) (.f64 #s(literal -1/12 binary64) re)) im) im)
(/ 1 (exp (* -1 im)))
(exp.f64 im)
(* 1/2 (* (sin re) (+ (exp (* -1 im)) (/ 1 (exp (* -1 im))))))
(*.f64 (fma.f64 (exp.f64 im) #s(literal 1/2 binary64) (/.f64 #s(literal 1/2 binary64) (exp.f64 im))) (sin.f64 re))
(* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))
(*.f64 (fma.f64 (exp.f64 im) #s(literal 1/2 binary64) (/.f64 #s(literal 1/2 binary64) (exp.f64 im))) (sin.f64 re))
(exp (* -1 im))
(exp.f64 (neg.f64 im))

rewrite93.0ms (1.3%)

Memory

-9.0MiB live, 140.3MiB allocated; 16ms collecting garbage

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	58	394
0	95	378
1	317	364
0	2226	364

Stop Event

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

Counts

27 → 315

Calls

Call 1

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

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

eval63.0ms (0.9%)

Memory: 6.9MiB live, 149.3MiB allocated; 14ms collecting garbage
Compiler: Compiled 19 232 to 2 235 computations (88.4% saved)

prune32.0ms (0.5%)

Memory

-3.5MiB live, 91.0MiB allocated; 5ms collecting garbage

Pruning

26 alts after pruning (23 fresh and 3 done)

	Pruned	Kept	Total
New	454	18	472
Fresh	2	5	7
Picked	3	2	5
Done	0	1	1
Total	459	26	485

Accuracy

100.0%

Counts

485 → 26

Alt Table

Click to see full alt table

Status	Accuracy	Program
	55.9%	(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))
	62.7%	(.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (*.f64 re re) #s(literal 1 binary64)) re))) #s(literal 1/2 binary64))
▶	91.4%	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))
	88.0%	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 #s(literal 1/12 binary64) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64))))
	65.5%	(.f64 #s(approx ( 1/2 (sin re)) (*.f64 #s(literal 1/2 binary64) re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)))))
✓	76.3%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re)))
	51.8%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (fma.f64 (.f64 re (.f64 re re)) (-.f64 (.f64 (fma.f64 #s(literal -1/5040 binary64) (.f64 re re) #s(literal 1/120 binary64)) (*.f64 re re)) #s(literal 1/6 binary64)) re))))
✓	51.8%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (fma.f64 (.f64 re (.f64 re re)) (-.f64 (.f64 (.f64 (fma.f64 #s(literal -1/5040 binary64) (*.f64 re re) #s(literal 1/120 binary64)) re) re) #s(literal 1/6 binary64)) re))))
	55.1%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (fma.f64 (.f64 re (.f64 re re)) (-.f64 (.f64 #s(approx ( (+ (* -1/5040 (* re re)) 1/120) re) (*.f64 #s(literal 1/120 binary64) re)) re) #s(literal 1/6 binary64)) re))))
	56.0%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 #s(approx (+ ( (* 1/2 im) im) 1) #s(literal 1 binary64)) (sin.f64 re)))
	36.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re (.f64 (.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64)) re) re) re))))
	52.2%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re (*.f64 #s(literal 1 binary64) re))))
	23.8%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (/.f64 (-.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 0 binary64)) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)))
	54.7%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (/.f64 (.f64 (*.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)))
▶	37.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
✓	52.2%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)))
▶	36.3%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
	37.9%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (fma.f64 #s(literal -1/6 binary64) (*.f64 re re) #s(literal 1 binary64))) re)))
	36.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (-.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) im) im (/.f64 (/.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re) re)) #s(literal 1/6 binary64)) (.f64 re re))) re)))
	22.3%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im)) re)))
▶	11.1%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re)))
	23.8%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* im im) 1/2) 1) (.f64 (.f64 im im) #s(literal 1/2 binary64))) re)))
	16.8%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal -1/12 binary64) (.f64 #s(literal 1/2 binary64) im)) re)) im)))
▶	18.3%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)))
	16.6%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) #s(approx (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (.f64 (.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re) im) im))))
	29.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) #s(approx (* (+ (* (* im im) 1/2) 1) re) (.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) re (/.f64 re (*.f64 im im))) im) im))))

Compiler

Compiled 2 026 to 1 367 computations (32.5% saved)

simplify207.0ms (2.9%)

Memory

37.4MiB live, 307.8MiB allocated; 55ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re))
cost-diff	0	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
cost-diff	2	(/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im)
cost-diff	4	(.f64 (.f64 im (neg.f64 im)) (neg.f64 im))
cost-diff	0	(fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)))
cost-diff	0	(.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
cost-diff	0	#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re))
cost-diff	0	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
cost-diff	0	#s(approx (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re))
cost-diff	0	(.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re)
cost-diff	0	#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re))
cost-diff	0	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re)))
cost-diff	0	#s(approx (* (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64)))
cost-diff	0	(.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)
cost-diff	0	#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im))
cost-diff	0	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)))
cost-diff	0	#s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))
cost-diff	0	(sin.f64 re)
cost-diff	0	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
cost-diff	0	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	79	783
0	117	721
1	244	705
2	838	669
3	6083	669
0	8535	669

Stop Event

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

Calls

Call 1

Inputs
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
#s(literal 1/2 binary64)
(sin.f64 re)
re
#s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))
(fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64))
(fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64))
#s(literal 1/360 binary64)
(*.f64 im im)
im
#s(literal 1/12 binary64)
#s(literal 1 binary64)
#s(literal 2 binary64)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im))
(.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)
#s(approx (* (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64)))
(.f64 (.f64 re im) #s(literal 1/2 binary64))
(*.f64 re im)
re
im
#s(literal 1/2 binary64)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re))
(.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re)
#s(approx (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re))
(.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)
(.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)
(fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64))
(*.f64 im im)
im
#s(literal -1/12 binary64)
#s(literal -1/6 binary64)
re
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re))
(.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)))
#s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (*.f64 im im) re) #s(literal -1/12 binary64)))
(.f64 (.f64 (*.f64 im im) re) #s(literal -1/12 binary64))
(.f64 (.f64 im im) re)
(*.f64 im im)
im
re
#s(literal -1/12 binary64)
(fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))
#s(literal 1/2 binary64)
#s(literal 1 binary64)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re))
(.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)))
(.f64 (fma.f64 (/.f64 (.f64 (*.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)
(fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64))
(/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im)
(.f64 (.f64 im (neg.f64 im)) (neg.f64 im))
(*.f64 im (neg.f64 im))
im
(neg.f64 im)
#s(literal -1/12 binary64)
#s(literal -1/6 binary64)
re
(fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))
(*.f64 im im)
#s(literal 1/2 binary64)
#s(literal 1 binary64)

Outputs
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))
(.f64 (.f64 (sin.f64 re) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/360 binary64) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
#s(literal 1/2 binary64)
(sin.f64 re)
re
#s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))
#s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/360 binary64) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))
(fma.f64 (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/360 binary64) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))
(fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/360 binary64) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64))
(fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64))
(fma.f64 (*.f64 im im) #s(literal 1/360 binary64) #s(literal 1/12 binary64))
#s(literal 1/360 binary64)
(*.f64 im im)
im
#s(literal 1/12 binary64)
#s(literal 1 binary64)
#s(literal 2 binary64)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 im re) #s(literal 1/2 binary64))) im)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 im re) #s(literal 1/2 binary64))) im))
(.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)
(.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 im re) #s(literal 1/2 binary64))) im)
#s(approx (* (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64)))
#s(approx (* (* (sin re) 1/2) im) (.f64 (.f64 im re) #s(literal 1/2 binary64)))
(.f64 (.f64 re im) #s(literal 1/2 binary64))
(.f64 (.f64 im re) #s(literal 1/2 binary64))
(*.f64 re im)
(*.f64 im re)
re
im
#s(literal 1/2 binary64)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64)) re) re)) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64)) re) re)) re))
(.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re)
(.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64)) re) re)) re)
#s(approx (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re))
#s(approx (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64)) re) re))
(.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)
(.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64)) re) re)
(.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)
(.f64 (fma.f64 #s(literal -1/12 binary64) (.f64 im im) #s(literal -1/6 binary64)) re)
(fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64))
(fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64))
(*.f64 im im)
im
#s(literal -1/12 binary64)
#s(literal -1/6 binary64)
re
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))) re))
(.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))) re)
(fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)))
(fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)))
#s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (*.f64 im im) re) #s(literal -1/12 binary64)))
#s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re))
(.f64 (.f64 (*.f64 im im) re) #s(literal -1/12 binary64))
(.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)
(.f64 (.f64 im im) re)
(.f64 (.f64 im re) im)
(*.f64 im im)
im
re
#s(literal -1/12 binary64)
(fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))
(fma.f64 (*.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))
#s(literal 1/2 binary64)
#s(literal 1 binary64)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (.f64 im im) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (.f64 im im) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))) re))
(.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(.f64 (fma.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (.f64 im im) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))) re)
(fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)))
(fma.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (.f64 im im) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)))
(.f64 (fma.f64 (/.f64 (.f64 (*.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)
(.f64 (fma.f64 #s(literal -1/12 binary64) (.f64 im im) #s(literal -1/6 binary64)) re)
(fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64))
(fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64))
(/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im)
(*.f64 im im)
(.f64 (.f64 im (neg.f64 im)) (neg.f64 im))
(pow.f64 im #s(literal 3 binary64))
(*.f64 im (neg.f64 im))
(*.f64 (neg.f64 im) im)
im
(neg.f64 im)
#s(literal -1/12 binary64)
#s(literal -1/6 binary64)
re
(fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))
(fma.f64 (*.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))
(*.f64 im im)
#s(literal 1/2 binary64)
#s(literal 1 binary64)

localize379.0ms (5.4%)

Memory

30.2MiB live, 457.6MiB allocated; 248ms collecting garbage

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.18359375	(.f64 (fma.f64 (/.f64 (.f64 (*.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)
accuracy	0.645815830770955	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
accuracy	5.268451575898618	(/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im)
accuracy	15.608225427409614	#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re))
accuracy	0.645815830770955	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
accuracy	2.8273575708992524	(.f64 (.f64 im im) re)
accuracy	15.608225427409614	#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re))
accuracy	34.008798179671906	#s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (*.f64 im im) re) #s(literal -1/12 binary64)))
accuracy	0.18359375	(.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)
accuracy	0.645815830770955	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re)))
accuracy	15.608225427409614	#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re))
accuracy	20.066995621083098	#s(approx (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re))
accuracy	0.0546875	(.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)
accuracy	0.645815830770955	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)))
accuracy	15.453886270145574	#s(approx (* (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64)))
accuracy	33.959248484280266	#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im))
accuracy	0.00390625	(fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64))
accuracy	0.00390625	(sin.f64 re)
accuracy	0.0078125	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))
accuracy	0.520433349999479	#s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))

Samples

273.0ms	142×	0	valid
48.0ms	111×	0	exit
9.0ms	1×	5	exit
3.0ms	2×	1	valid

Compiler

Compiled 483 to 64 computations (86.7% saved)

Precisions

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

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

const: 44.0ms (27.3% of total)

ival-sin: 20.0ms (12.4% of total)

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

ival-exp: 8.0ms (5% of total)

ival-cosh: 5.0ms (3.1% of total)

ival-div: 3.0ms (1.9% of total)

ival-sinh: 3.0ms (1.9% of total)

ival-sub: 2.0ms (1.2% of total)

adjust: 1.0ms (0.6% of total)

exact: 1.0ms (0.6% of total)

ival-neg: 1.0ms (0.6% of total)

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

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

series75.0ms (1.1%)

Memory

30.7MiB live, 127.9MiB allocated; 14ms collecting garbage

Counts

25 → 74

Calls

Call 1

Inputs
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
(sin.f64 re)
#s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im))
(.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)
#s(approx (* (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re))
(.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re)
#s(approx (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re))
(.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)))
(.f64 (.f64 im (neg.f64 im)) (neg.f64 im))
(/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re))
(fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64))
(.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)
#s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (*.f64 im im) re) #s(literal -1/12 binary64)))
(.f64 (.f64 im im) re)
(.f64 (fma.f64 (/.f64 (.f64 (*.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)

Outputs
(* 1/2 (* re (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))
(* re (+ (* -1/12 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))) (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))))
(* re (+ (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* 1/240 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))))))
(* re (+ (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))) (* 1/240 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))))))))
(* 1/2 re)
(* re (+ 1/2 (* -1/12 (pow re 2))))
(* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))
(* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))
re
(* re (+ 1 (* -1/6 (pow re 2))))
(* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))
(* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))
(* 1/2 (* re (+ (exp im) (exp (neg im)))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* 1/240 (* (pow re 2) (+ (exp im) (exp (neg im)))))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/240 (+ (exp im) (exp (neg im))))))))))
(* re (+ 1 (* 1/2 (pow im 2))))
(* re (+ 1 (+ (* -1/6 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/2 (pow im 2)))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* 1/120 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))))))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/120 (+ 1 (* 1/2 (pow im 2)))))))))))
(* 1/2 (* (pow im 2) re))
(* re (+ (* -1/12 (* (pow im 2) (pow re 2))) (* 1/2 (pow im 2))))
(* re (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/12 (pow im 2)) (* 1/240 (* (pow im 2) (pow re 2)))))))
(* re (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/12 (pow im 2)) (* (pow re 2) (+ (* -1/10080 (* (pow im 2) (pow re 2))) (* 1/240 (pow im 2))))))))
(* 1/2 (* im re))
(* re (+ (* -1/12 (* im (pow re 2))) (* 1/2 im)))
(* re (+ (* 1/2 im) (* (pow re 2) (+ (* -1/12 im) (* 1/240 (* im (pow re 2)))))))
(* re (+ (* 1/2 im) (* (pow re 2) (+ (* -1/12 im) (* (pow re 2) (+ (* -1/10080 (* im (pow re 2))) (* 1/240 im)))))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (- (* -1/12 (pow im 2)) 1/6)))))
(+ 1 (* 1/2 (pow im 2)))
(+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (- (* -1/12 (pow im 2)) 1/6))))
(* re (- (* -1/12 (pow im 2)) 1/6))
(* (pow im 2) re)
(* 1/2 (* (sin re) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))
(* 1/2 (sin re))
(sin re)
(* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))
(* (sin re) (+ 1 (* 1/2 (pow im 2))))
(* 1/2 (* (pow im 2) (sin re)))
(* 1/2 (* im (sin re)))
(* (pow re 3) (- (* -1/12 (pow im 2)) 1/6))
(* (pow re 3) (- (+ (* -1/12 (pow im 2)) (+ (* 1/2 (/ (pow im 2) (pow re 2))) (/ 1 (pow re 2)))) 1/6))
(* (pow re 2) (- (* -1/12 (pow im 2)) 1/6))
(* (pow re 2) (- (+ (* -1/12 (pow im 2)) (+ (* 1/2 (/ (pow im 2) (pow re 2))) (/ 1 (pow re 2)))) 1/6))
(* -1 (* (pow re 3) (+ (* -1 (- (* -1/12 (pow im 2)) 1/6)) (* -1 (/ (+ 1 (* 1/2 (pow im 2))) (pow re 2))))))
(+ (sin re) (* 1/2 (* (pow im 2) (sin re))))
(+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))
2
(+ 2 (pow im 2))
(+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))
(+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))
(+ (* re (+ 1 (* -1/6 (pow re 2)))) (* (pow im 2) (* re (+ 1/2 (* -1/12 (pow re 2))))))
(+ 1 (* -1/6 (pow re 2)))
(+ 1 (+ (* -1/6 (pow re 2)) (* (pow im 2) (+ 1/2 (* -1/12 (pow re 2))))))
(pow im 3)
(pow im 2)
1/12
(+ 1/12 (* 1/360 (pow im 2)))
(* -1/6 re)
(+ (* -1/6 re) (* -1/12 (* (pow im 2) re)))
(- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))
(* (pow im 2) (+ (* 1/2 (sin re)) (/ (sin re) (pow im 2))))
(* (pow im 2) (* re (+ 1/2 (* -1/12 (pow re 2)))))
(* (pow im 2) (+ (* re (+ 1/2 (* -1/12 (pow re 2)))) (/ (* re (+ 1 (* -1/6 (pow re 2)))) (pow im 2))))
(* (pow im 2) (+ 1/2 (* -1/12 (pow re 2))))
(* (pow im 2) (+ 1/2 (+ (* -1/6 (/ (pow re 2) (pow im 2))) (+ (* -1/12 (pow re 2)) (/ 1 (pow im 2))))))
(* 1/360 (pow im 2))
(* (pow im 2) (+ 1/360 (* 1/12 (/ 1 (pow im 2)))))
(* -1/12 (* (pow im 2) re))
(* (pow im 2) (+ (* -1/6 (/ re (pow im 2))) (* -1/12 re)))
(* 1/2 (* (sin re) (- (+ (exp (* -1 im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (* -1 im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (* -1 im)))))))
(- (+ (exp (* -1 im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (* -1 im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (* -1 im)))))
(* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))

Calls

6 calls:

Time	Variable		Point	Expression
30.0ms	re	@	-inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))))) (* 1/2 (sin re)) (sin re) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (* (* (sin re) 1/2) im) im) (* (* (sin re) 1/2) im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* (* im (neg im)) (neg im)) (/ (* (* im (neg im)) (neg im)) im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* 1/360 (* im im)) 1/12) (* (+ (* (* im im) -1/12) -1/6) re) (* (+ (* (* im im) -1/12) -1/6) re) (* (* im im) re) (* (+ (* (/ (* (* im (neg im)) (neg im)) im) -1/12) -1/6) re))
16.0ms	im	@	0	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))))) (* 1/2 (sin re)) (sin re) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (* (* (sin re) 1/2) im) im) (* (* (sin re) 1/2) im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* (* im (neg im)) (neg im)) (/ (* (* im (neg im)) (neg im)) im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* 1/360 (* im im)) 1/12) (* (+ (* (* im im) -1/12) -1/6) re) (* (+ (* (* im im) -1/12) -1/6) re) (* (* im im) re) (* (+ (* (/ (* (* im (neg im)) (neg im)) im) -1/12) -1/6) re))
9.0ms	im	@	inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))))) (* 1/2 (sin re)) (sin re) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (* (* (sin re) 1/2) im) im) (* (* (sin re) 1/2) im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* (* im (neg im)) (neg im)) (/ (* (* im (neg im)) (neg im)) im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* 1/360 (* im im)) 1/12) (* (+ (* (* im im) -1/12) -1/6) re) (* (+ (* (* im im) -1/12) -1/6) re) (* (* im im) re) (* (+ (* (/ (* (* im (neg im)) (neg im)) im) -1/12) -1/6) re))
9.0ms	im	@	-inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))))) (* 1/2 (sin re)) (sin re) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (* (* (sin re) 1/2) im) im) (* (* (sin re) 1/2) im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* (* im (neg im)) (neg im)) (/ (* (* im (neg im)) (neg im)) im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* 1/360 (* im im)) 1/12) (* (+ (* (* im im) -1/12) -1/6) re) (* (+ (* (* im im) -1/12) -1/6) re) (* (* im im) re) (* (+ (* (/ (* (* im (neg im)) (neg im)) im) -1/12) -1/6) re))
5.0ms	re	@	inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im))))) (* 1/2 (sin re)) (sin re) (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (* (* (sin re) 1/2) im) im) (* (* (sin re) 1/2) im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (* (* im (neg im)) (neg im)) (/ (* (* im (neg im)) (neg im)) im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (+ (* (* 1/2 im) im) 1) (sin re)) (+ (* 1/360 (* im im)) 1/12) (* (+ (* (* im im) -1/12) -1/6) re) (* (+ (* (* im im) -1/12) -1/6) re) (* (* im im) re) (* (+ (* (/ (* (* im (neg im)) (neg im)) im) -1/12) -1/6) re))

simplify167.0ms (2.4%)

Memory

-30.1MiB live, 249.0MiB allocated; 21ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	273	1531
1	1067	1305
2	4905	1264
0	8285	1157

Stop Event

1×	iter limit
1×	node limit

Counts

74 → 73

Calls

Call 1

Inputs
(* 1/2 (* re (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))
(* re (+ (* -1/12 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))) (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))))
(* re (+ (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* 1/240 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))))))
(* re (+ (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))) (* 1/240 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))))))))
(* 1/2 re)
(* re (+ 1/2 (* -1/12 (pow re 2))))
(* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))
(* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))
re
(* re (+ 1 (* -1/6 (pow re 2))))
(* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))
(* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))
(* 1/2 (* re (+ (exp im) (exp (neg im)))))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* 1/240 (* (pow re 2) (+ (exp im) (exp (neg im)))))))))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/240 (+ (exp im) (exp (neg im))))))))))
(* re (+ 1 (* 1/2 (pow im 2))))
(* re (+ 1 (+ (* -1/6 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/2 (pow im 2)))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* 1/120 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))))))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/120 (+ 1 (* 1/2 (pow im 2)))))))))))
(* 1/2 (* (pow im 2) re))
(* re (+ (* -1/12 (* (pow im 2) (pow re 2))) (* 1/2 (pow im 2))))
(* re (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/12 (pow im 2)) (* 1/240 (* (pow im 2) (pow re 2)))))))
(* re (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/12 (pow im 2)) (* (pow re 2) (+ (* -1/10080 (* (pow im 2) (pow re 2))) (* 1/240 (pow im 2))))))))
(* 1/2 (* im re))
(* re (+ (* -1/12 (* im (pow re 2))) (* 1/2 im)))
(* re (+ (* 1/2 im) (* (pow re 2) (+ (* -1/12 im) (* 1/240 (* im (pow re 2)))))))
(* re (+ (* 1/2 im) (* (pow re 2) (+ (* -1/12 im) (* (pow re 2) (+ (* -1/10080 (* im (pow re 2))) (* 1/240 im)))))))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (- (* -1/12 (pow im 2)) 1/6)))))
(+ 1 (* 1/2 (pow im 2)))
(+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (- (* -1/12 (pow im 2)) 1/6))))
(* re (- (* -1/12 (pow im 2)) 1/6))
(* (pow im 2) re)
(* 1/2 (* (sin re) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))
(* 1/2 (sin re))
(sin re)
(* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))
(* (sin re) (+ 1 (* 1/2 (pow im 2))))
(* 1/2 (* (pow im 2) (sin re)))
(* 1/2 (* im (sin re)))
(* (pow re 3) (- (* -1/12 (pow im 2)) 1/6))
(* (pow re 3) (- (+ (* -1/12 (pow im 2)) (+ (* 1/2 (/ (pow im 2) (pow re 2))) (/ 1 (pow re 2)))) 1/6))
(* (pow re 2) (- (* -1/12 (pow im 2)) 1/6))
(* (pow re 2) (- (+ (* -1/12 (pow im 2)) (+ (* 1/2 (/ (pow im 2) (pow re 2))) (/ 1 (pow re 2)))) 1/6))
(* -1 (* (pow re 3) (+ (* -1 (- (* -1/12 (pow im 2)) 1/6)) (* -1 (/ (+ 1 (* 1/2 (pow im 2))) (pow re 2))))))
(+ (sin re) (* 1/2 (* (pow im 2) (sin re))))
(+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))
2
(+ 2 (pow im 2))
(+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))
(+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))
(+ (* re (+ 1 (* -1/6 (pow re 2)))) (* (pow im 2) (* re (+ 1/2 (* -1/12 (pow re 2))))))
(+ 1 (* -1/6 (pow re 2)))
(+ 1 (+ (* -1/6 (pow re 2)) (* (pow im 2) (+ 1/2 (* -1/12 (pow re 2))))))
(pow im 3)
(pow im 2)
1/12
(+ 1/12 (* 1/360 (pow im 2)))
(* -1/6 re)
(+ (* -1/6 re) (* -1/12 (* (pow im 2) re)))
(- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))
(* (pow im 2) (+ (* 1/2 (sin re)) (/ (sin re) (pow im 2))))
(* (pow im 2) (* re (+ 1/2 (* -1/12 (pow re 2)))))
(* (pow im 2) (+ (* re (+ 1/2 (* -1/12 (pow re 2)))) (/ (* re (+ 1 (* -1/6 (pow re 2)))) (pow im 2))))
(* (pow im 2) (+ 1/2 (* -1/12 (pow re 2))))
(* (pow im 2) (+ 1/2 (+ (* -1/6 (/ (pow re 2) (pow im 2))) (+ (* -1/12 (pow re 2)) (/ 1 (pow im 2))))))
(* 1/360 (pow im 2))
(* (pow im 2) (+ 1/360 (* 1/12 (/ 1 (pow im 2)))))
(* -1/12 (* (pow im 2) re))
(* (pow im 2) (+ (* -1/6 (/ re (pow im 2))) (* -1/12 re)))
(* 1/2 (* (sin re) (- (+ (exp (* -1 im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (* -1 im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (* -1 im)))))))
(- (+ (exp (* -1 im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (* -1 im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (* -1 im)))))
(* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))

Outputs
(* 1/2 (* re (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))
(.f64 (.f64 #s(literal 1/2 binary64) re) (-.f64 (exp.f64 (neg.f64 im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (pow.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) (*.f64 (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (exp.f64 (neg.f64 im)))))
(* re (+ (* -1/12 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))) (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))))
(.f64 (.f64 (-.f64 (exp.f64 (neg.f64 im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (pow.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) (.f64 (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (exp.f64 (neg.f64 im)))) (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64))) re)
(* re (+ (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* 1/240 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (.f64 (-.f64 (exp.f64 (neg.f64 im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (pow.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) (.f64 (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (exp.f64 (neg.f64 im)))) (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) re) (-.f64 (exp.f64 (neg.f64 im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (pow.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) (.f64 (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (exp.f64 (neg.f64 im))))))
(* re (+ (* 1/2 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))) (* 1/240 (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im))))))))))))
(.f64 (fma.f64 (-.f64 (exp.f64 (neg.f64 im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (pow.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) (.f64 (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (exp.f64 (neg.f64 im)))) (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (-.f64 (exp.f64 (neg.f64 im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (pow.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) (.f64 (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (exp.f64 (neg.f64 im)))) (fma.f64 #s(literal -1/10080 binary64) (*.f64 re re) #s(literal 1/240 binary64))))) re)
(* 1/2 re)
(*.f64 #s(literal 1/2 binary64) re)
(* re (+ 1/2 (* -1/12 (pow re 2))))
(.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)
(* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))
(.f64 (fma.f64 (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64)) (*.f64 re re) #s(literal 1/2 binary64)) re)
(* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))
(.f64 (fma.f64 (fma.f64 (fma.f64 #s(literal -1/10080 binary64) (.f64 re re) #s(literal 1/240 binary64)) (.f64 re re) #s(literal -1/12 binary64)) (.f64 re re) #s(literal 1/2 binary64)) re)
re
(* re (+ 1 (* -1/6 (pow re 2))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64) re)
(* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (fma.f64 #s(literal 1/120 binary64) (*.f64 re re) #s(literal -1/6 binary64)) re)
(* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (fma.f64 (fma.f64 #s(literal -1/5040 binary64) (.f64 re re) #s(literal 1/120 binary64)) (.f64 re re) #s(literal -1/6 binary64)) re)
(* 1/2 (* re (+ (exp im) (exp (neg im)))))
(.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (.f64 #s(literal 1/2 binary64) re))
(* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))
(.f64 (.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64))) re)
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* 1/240 (* (pow re 2) (+ (exp im) (exp (neg im)))))))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64))) (.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (.f64 #s(literal 1/2 binary64) re)))
(* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/12 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/240 (+ (exp im) (exp (neg im))))))))))
(.f64 (fma.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (fma.f64 #s(literal -1/10080 binary64) (*.f64 re re) #s(literal 1/240 binary64))))) re)
(* re (+ 1 (* 1/2 (pow im 2))))
(.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)
(* re (+ 1 (+ (* -1/6 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/2 (pow im 2)))))
(.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* 1/120 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))))))))
(.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 #s(literal 1/120 binary64) (.f64 re re) #s(literal -1/6 binary64))) (.f64 re re) (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/6 (+ 1 (* 1/2 (pow im 2)))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (+ 1 (* 1/2 (pow im 2))))) (* 1/120 (+ 1 (* 1/2 (pow im 2)))))))))))
(.f64 (fma.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (fma.f64 #s(literal -1/5040 binary64) (.f64 re re) #s(literal 1/120 binary64))) (.f64 re re) (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64))) (.f64 re re) (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(* 1/2 (* (pow im 2) re))
(.f64 (.f64 (*.f64 im im) re) #s(literal 1/2 binary64))
(* re (+ (* -1/12 (* (pow im 2) (pow re 2))) (* 1/2 (pow im 2))))
(.f64 (.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re) im) im)
(* re (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/12 (pow im 2)) (* 1/240 (* (pow im 2) (pow re 2)))))))
(.f64 (fma.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im (.f64 (.f64 (.f64 im im) #s(literal 1/240 binary64)) (pow.f64 re #s(literal 4 binary64)))) re)
(* re (+ (* 1/2 (pow im 2)) (* (pow re 2) (+ (* -1/12 (pow im 2)) (* (pow re 2) (+ (* -1/10080 (* (pow im 2) (pow re 2))) (* 1/240 (pow im 2))))))))
(.f64 (fma.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im (.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 (.f64 (.f64 im im) re) re) #s(literal -1/10080 binary64) (.f64 (*.f64 im im) #s(literal 1/240 binary64))))) re)
(* 1/2 (* im re))
(.f64 (.f64 im re) #s(literal 1/2 binary64))
(* re (+ (* -1/12 (* im (pow re 2))) (* 1/2 im)))
(.f64 (fma.f64 (.f64 (.f64 im re) re) #s(literal -1/12 binary64) (.f64 #s(literal 1/2 binary64) im)) re)
(* re (+ (* 1/2 im) (* (pow re 2) (+ (* -1/12 im) (* 1/240 (* im (pow re 2)))))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (fma.f64 (.f64 (.f64 im re) re) #s(literal 1/240 binary64) (.f64 #s(literal -1/12 binary64) im)) (.f64 (*.f64 im re) #s(literal 1/2 binary64)))
(* re (+ (* 1/2 im) (* (pow re 2) (+ (* -1/12 im) (* (pow re 2) (+ (* -1/10080 (* im (pow re 2))) (* 1/240 im)))))))
(fma.f64 (pow.f64 re #s(literal 3 binary64)) (fma.f64 (.f64 (fma.f64 (.f64 (.f64 im re) re) #s(literal -1/10080 binary64) (.f64 #s(literal 1/240 binary64) im)) re) re (.f64 #s(literal -1/12 binary64) im)) (.f64 (*.f64 im re) #s(literal 1/2 binary64)))
(* re (+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (- (* -1/12 (pow im 2)) 1/6)))))
(.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(+ 1 (* 1/2 (pow im 2)))
(fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))
(+ 1 (+ (* 1/2 (pow im 2)) (* (pow re 2) (- (* -1/12 (pow im 2)) 1/6))))
(fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)))
(* re (- (* -1/12 (pow im 2)) 1/6))
(.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)
(* (pow im 2) re)
(.f64 (.f64 im im) re)
(* 1/2 (* (sin re) (- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))))
(.f64 (.f64 (-.f64 (exp.f64 (neg.f64 im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (pow.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) (*.f64 (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (exp.f64 (neg.f64 im)))) (sin.f64 re)) #s(literal 1/2 binary64))
(* 1/2 (sin re))
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
(sin re)
(sin.f64 re)
(* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))
(*.f64 (fma.f64 (exp.f64 im) #s(literal 1/2 binary64) (/.f64 #s(literal 1/2 binary64) (exp.f64 im))) (sin.f64 re))
(* (sin re) (+ 1 (* 1/2 (pow im 2))))
(.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (sin.f64 re))
(* 1/2 (* (pow im 2) (sin re)))
(.f64 (.f64 (*.f64 (sin.f64 re) im) #s(literal 1/2 binary64)) im)
(* 1/2 (* im (sin re)))
(.f64 (.f64 (sin.f64 re) im) #s(literal 1/2 binary64))
(* (pow re 3) (- (* -1/12 (pow im 2)) 1/6))
(.f64 (pow.f64 re #s(literal 3 binary64)) (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)))
(* (pow re 3) (- (+ (* -1/12 (pow im 2)) (+ (* 1/2 (/ (pow im 2) (pow re 2))) (/ 1 (pow re 2)))) 1/6))
(.f64 (-.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) im) im (/.f64 (/.f64 (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re) re)) #s(literal 1/6 binary64)) (pow.f64 re #s(literal 3 binary64)))
(* (pow re 2) (- (* -1/12 (pow im 2)) 1/6))
(.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)
(* (pow re 2) (- (+ (* -1/12 (pow im 2)) (+ (* 1/2 (/ (pow im 2) (pow re 2))) (/ 1 (pow re 2)))) 1/6))
(.f64 (-.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) im) im (/.f64 (/.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re) re)) #s(literal 1/6 binary64)) (.f64 re re))
(* -1 (* (pow re 3) (+ (* -1 (- (* -1/12 (pow im 2)) 1/6)) (* -1 (/ (+ 1 (* 1/2 (pow im 2))) (pow re 2))))))
(.f64 (-.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) im) im (/.f64 (/.f64 (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re) re)) #s(literal 1/6 binary64)) (pow.f64 re #s(literal 3 binary64)))
(+ (sin re) (* 1/2 (* (pow im 2) (sin re))))
(.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (sin.f64 re))
(+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))
(fma.f64 (.f64 (sin.f64 re) (fma.f64 #s(literal 1/24 binary64) (.f64 im im) #s(literal 1/2 binary64))) (*.f64 im im) (sin.f64 re))
(+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))
(fma.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) (sin.f64 re) (.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (sin.f64 re) (fma.f64 #s(literal 1/720 binary64) (.f64 im im) #s(literal 1/24 binary64)))))
2
#s(literal 2 binary64)
(+ 2 (pow im 2))
(fma.f64 im im #s(literal 2 binary64))
(+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))
(fma.f64 im im (fma.f64 (pow.f64 im #s(literal 4 binary64)) #s(literal 1/12 binary64) #s(literal 2 binary64)))
(+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))
(fma.f64 im im (fma.f64 (pow.f64 im #s(literal 4 binary64)) (fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64)) #s(literal 2 binary64)))
(+ (* re (+ 1 (* -1/6 (pow re 2)))) (* (pow im 2) (* re (+ 1/2 (* -1/12 (pow re 2))))))
(fma.f64 (.f64 (.f64 (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re) im) im (fma.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64) re))
(+ 1 (* -1/6 (pow re 2)))
(fma.f64 (*.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64))
(+ 1 (+ (* -1/6 (pow re 2)) (* (pow im 2) (+ 1/2 (* -1/12 (pow re 2))))))
(fma.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im (fma.f64 (*.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64)))
(pow im 3)
(pow.f64 im #s(literal 3 binary64))
(pow im 2)
(*.f64 im im)
1/12
#s(literal 1/12 binary64)
(+ 1/12 (* 1/360 (pow im 2)))
(fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64))
(* -1/6 re)
(*.f64 #s(literal -1/6 binary64) re)
(+ (* -1/6 re) (* -1/12 (* (pow im 2) re)))
(.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)
(- (+ (exp (neg im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (neg im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (neg im)))))
(-.f64 (exp.f64 (neg.f64 im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (pow.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) (*.f64 (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (exp.f64 (neg.f64 im))))
(* (pow im 2) (+ (* 1/2 (sin re)) (/ (sin re) (pow im 2))))
(.f64 (fma.f64 (sin.f64 re) #s(literal 1/2 binary64) (/.f64 (/.f64 (sin.f64 re) im) im)) (.f64 im im))
(* (pow im 2) (* re (+ 1/2 (* -1/12 (pow re 2)))))
(.f64 (.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re) im) im)
(* (pow im 2) (+ (* re (+ 1/2 (* -1/12 (pow re 2)))) (/ (* re (+ 1 (* -1/6 (pow re 2)))) (pow im 2))))
(.f64 (fma.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re (/.f64 (fma.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64) re) (.f64 im im))) (.f64 im im))
(* (pow im 2) (+ 1/2 (* -1/12 (pow re 2))))
(.f64 (.f64 (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im)
(* (pow im 2) (+ 1/2 (+ (* -1/6 (/ (pow re 2) (pow im 2))) (+ (* -1/12 (pow re 2)) (/ 1 (pow im 2))))))
(.f64 (+.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) re) re (/.f64 (/.f64 (fma.f64 (.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64)) im) im)) #s(literal 1/2 binary64)) (.f64 im im))
(* 1/360 (pow im 2))
(.f64 #s(literal 1/360 binary64) (.f64 im im))
(* (pow im 2) (+ 1/360 (* 1/12 (/ 1 (pow im 2)))))
(.f64 (.f64 (+.f64 (/.f64 #s(literal 1/12 binary64) (*.f64 im im)) #s(literal 1/360 binary64)) im) im)
(* -1/12 (* (pow im 2) re))
(.f64 (.f64 (*.f64 im im) #s(literal -1/12 binary64)) re)
(* (pow im 2) (+ (* -1/6 (/ re (pow im 2))) (* -1/12 re)))
(.f64 (.f64 (fma.f64 (/.f64 re (.f64 im im)) #s(literal -1/6 binary64) (.f64 #s(literal -1/12 binary64) re)) im) im)
(* 1/2 (* (sin re) (- (+ (exp (* -1 im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (* -1 im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (* -1 im)))))))
(.f64 (.f64 (-.f64 (exp.f64 (neg.f64 im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (pow.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) (*.f64 (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (exp.f64 (neg.f64 im)))) (sin.f64 re)) #s(literal 1/2 binary64))
(- (+ (exp (* -1 im)) (* 1/4 (/ (pow (+ (exp im) (/ 1 (exp im))) 2) (exp (* -1 im))))) (* 1/4 (/ (pow (- (exp im) (/ 1 (exp im))) 2) (exp (* -1 im)))))
(-.f64 (exp.f64 (neg.f64 im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (pow.f64 (+.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) (*.f64 (pow.f64 (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) #s(literal 2 binary64)) #s(literal 1/4 binary64))) (exp.f64 (neg.f64 im))))
(* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))
(*.f64 (fma.f64 (exp.f64 im) #s(literal 1/2 binary64) (/.f64 #s(literal 1/2 binary64) (exp.f64 im))) (sin.f64 re))

rewrite192.0ms (2.7%)

Memory

-1.9MiB live, 150.8MiB allocated; 104ms collecting garbage

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	79	612
0	117	564
1	423	528
0	3450	528

Stop Event

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

Counts

25 → 243

Calls

Call 1

Inputs
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
(sin.f64 re)
#s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im))
(.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)
#s(approx (* (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re))
(.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re)
#s(approx (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re))
(.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)
(fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)))
(.f64 (.f64 im (neg.f64 im)) (neg.f64 im))
(/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re))
(fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64))
(.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)
#s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (*.f64 im im) re) #s(literal -1/12 binary64)))
(.f64 (.f64 im im) re)
(.f64 (fma.f64 (/.f64 (.f64 (*.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re)

Outputs
(.f64 (.f64 #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/360 binary64) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))) #s(literal 1/2 binary64)) (sin.f64 re))
(.f64 (.f64 (sin.f64 re) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/360 binary64) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))) #s(literal 1/2 binary64))
(.f64 (sin.f64 re) (.f64 #s(literal 1/2 binary64) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/360 binary64) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))))
(.f64 #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/360 binary64) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64))) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/360 binary64) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))
(.f64 #s(literal 1/2 binary64) (.f64 (sin.f64 re) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/360 binary64) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))))
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
(sin.f64 re)
#s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/360 binary64) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 im re) #s(literal 1/2 binary64))) im)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 im re) #s(literal 1/2 binary64))) im))
(.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 im re) #s(literal 1/2 binary64))) im)
(.f64 im #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 im re) #s(literal 1/2 binary64))))
#s(approx (* (* (sin re) 1/2) im) (.f64 (.f64 im re) #s(literal 1/2 binary64)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64)) re) re)) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64)) re) re)) re))
(.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64)) re) re)) re)
(.f64 re #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64)) re) re)))
#s(approx (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64)) re) re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))) re))
(.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))) re)
(.f64 re (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))))
(/.f64 (.f64 (-.f64 (pow.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 2 binary64)) (pow.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) #s(literal 2 binary64))) re) (-.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))))
(/.f64 (.f64 (+.f64 (pow.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) #s(literal 3 binary64)) (pow.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 3 binary64))) re) (fma.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (-.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re)) (pow.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re) #s(literal 2 binary64))))
(/.f64 (.f64 re (-.f64 (pow.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 2 binary64)) (pow.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) #s(literal 2 binary64)))) (-.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))))
(/.f64 (.f64 re (+.f64 (pow.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) #s(literal 3 binary64)) (pow.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 3 binary64)))) (fma.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (-.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re)) (pow.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re) #s(literal 2 binary64))))
(fma.f64 (fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (.f64 im #s(literal 1/2 binary64)) im)) re (.f64 #s(literal 1 binary64) re))
(fma.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) re (.f64 (fma.f64 (*.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) re))
(fma.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) re (.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re) re))
(fma.f64 re (fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (.f64 im #s(literal 1/2 binary64)) im)) (.f64 re #s(literal 1 binary64)))
(fma.f64 re (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) (.f64 re (fma.f64 (*.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))))
(fma.f64 re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (.f64 re (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(+.f64 (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (.f64 im #s(literal 1/2 binary64)) im)) re) (.f64 #s(literal 1 binary64) re))
(+.f64 (.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) re) (.f64 (fma.f64 (*.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) re))
(+.f64 (.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) re) (.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re) re))
(+.f64 (.f64 re (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (.f64 im #s(literal 1/2 binary64)) im))) (.f64 re #s(literal 1 binary64)))
(+.f64 (.f64 re (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re)) (.f64 re (fma.f64 (*.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))))
(+.f64 (.f64 re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))) (.f64 re (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(/.f64 (-.f64 (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (.f64 im #s(literal 1/2 binary64)) im)) (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (.f64 im #s(literal 1/2 binary64)) im))) #s(literal 1 binary64)) (-.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (*.f64 im #s(literal 1/2 binary64)) im)) #s(literal 1 binary64)))
(/.f64 (-.f64 (pow.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) #s(literal 2 binary64)) (pow.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 2 binary64))) (-.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(/.f64 (+.f64 (pow.f64 (fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (.f64 im #s(literal 1/2 binary64)) im)) #s(literal 3 binary64)) #s(literal 1 binary64)) (fma.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (.f64 im #s(literal 1/2 binary64)) im)) (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (.f64 im #s(literal 1/2 binary64)) im)) (-.f64 #s(literal 1 binary64) (.f64 (fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (*.f64 im #s(literal 1/2 binary64)) im)) #s(literal 1 binary64)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 2 binary64)) (pow.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) #s(literal 3 binary64)) (pow.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (-.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re)) (pow.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 2 binary64)) (pow.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) #s(literal 2 binary64))) (-.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) #s(literal 3 binary64)) (pow.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 2 binary64)) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) (.f64 re (fma.f64 (*.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)))))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) #s(literal 3 binary64)) (pow.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 3 binary64))) (fma.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (-.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re)) (pow.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re) #s(literal 2 binary64))))
(fma.f64 (.f64 #s(literal 1/2 binary64) (fabs.f64 im)) (fabs.f64 im) (+.f64 #s(literal 1 binary64) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(fma.f64 (.f64 #s(literal 1/2 binary64) (neg.f64 im)) (neg.f64 im) (+.f64 #s(literal 1 binary64) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(fma.f64 (.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) (exp.f64 im)) (exp.f64 (neg.f64 im)) (+.f64 #s(literal 1 binary64) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(fma.f64 (fabs.f64 im) (.f64 (fabs.f64 im) #s(literal 1/2 binary64)) (+.f64 #s(literal 1 binary64) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(fma.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(fma.f64 (neg.f64 im) (.f64 (neg.f64 im) #s(literal 1/2 binary64)) (+.f64 #s(literal 1 binary64) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)))
(fma.f64 (.f64 im #s(literal 1/2 binary64)) (.f64 im #s(literal 1 binary64)) (+.f64 #s(literal 1 binary64) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(fma.f64 (.f64 im #s(literal 1/2 binary64)) im (+.f64 #s(literal 1 binary64) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(fma.f64 #s(literal 1 binary64) (.f64 (.f64 im #s(literal 1/2 binary64)) im) (+.f64 #s(literal 1 binary64) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(fma.f64 (.f64 im im) #s(literal 1/2 binary64) (+.f64 #s(literal 1 binary64) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(fma.f64 im (.f64 (.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64)) (+.f64 #s(literal 1 binary64) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(fma.f64 im (.f64 im #s(literal 1/2 binary64)) (+.f64 #s(literal 1 binary64) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(fma.f64 re #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)))
(fma.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) #s(literal 1 binary64)) (+.f64 #s(literal 1 binary64) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(fma.f64 #s(literal 1/2 binary64) (.f64 im im) (+.f64 #s(literal 1 binary64) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(-.f64 (+.f64 (fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (*.f64 im #s(literal 1/2 binary64)) im)) (pow.f64 (cosh.f64 im) #s(literal 2 binary64))) (pow.f64 (sinh.f64 im) #s(literal 2 binary64)))
(-.f64 (/.f64 (pow.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 2 binary64)) (-.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)))) (/.f64 (pow.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) #s(literal 2 binary64)) (-.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)))))
(-.f64 (fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (*.f64 im #s(literal 1/2 binary64)) im)) #s(literal -1 binary64))
(-.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (.f64 (neg.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re))) re))
(-.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (.f64 (neg.f64 re) #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re))))
(+.f64 (+.f64 (fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (*.f64 im #s(literal 1/2 binary64)) im)) (pow.f64 (cosh.f64 im) #s(literal 2 binary64))) (neg.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64))))
(+.f64 (fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re #s(literal 1 binary64)) (.f64 (*.f64 im #s(literal 1/2 binary64)) im))
(+.f64 (/.f64 (pow.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 3 binary64)) (fma.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (-.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re)) (pow.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) #s(literal 2 binary64)))) (/.f64 (pow.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) #s(literal 3 binary64)) (fma.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (-.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re)) (pow.f64 (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re) #s(literal 2 binary64)))))
(+.f64 (fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (*.f64 im #s(literal 1/2 binary64)) im)) #s(literal 1 binary64))
(+.f64 (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re) (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)))
(+.f64 (.f64 (.f64 im #s(literal 1/2 binary64)) im) (+.f64 #s(literal 1 binary64) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re)))
(+.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64)) (.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re)) re))
(+.f64 #s(literal 1 binary64) (fma.f64 #s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re)) re (.f64 (*.f64 im #s(literal 1/2 binary64)) im)))
(.f64 (.f64 im (fabs.f64 im)) (fabs.f64 im))
(*.f64 (pow.f64 im #s(literal 3/2 binary64)) (pow.f64 im #s(literal 3/2 binary64)))
(.f64 (.f64 (neg.f64 im) im) (neg.f64 im))
(.f64 (neg.f64 im) (.f64 (neg.f64 im) im))
(.f64 (.f64 im im) im)
(.f64 im (.f64 im im))
(pow.f64 im #s(literal 3 binary64))
(/.f64 (.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) (.f64 (neg.f64 im) im)) (*.f64 im im))
(/.f64 (.f64 (.f64 (neg.f64 im) im) (*.f64 (neg.f64 im) im)) im)
(/.f64 (.f64 (.f64 (neg.f64 im) im) (neg.f64 (pow.f64 im #s(literal 3 binary64)))) (*.f64 im im))
(neg.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))))
(exp.f64 (*.f64 (log.f64 im) #s(literal 3 binary64)))
(.f64 (/.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) (.f64 (neg.f64 im) im)) im)
(.f64 (/.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) (neg.f64 (pow.f64 im #s(literal 3 binary64)))) (.f64 im im))
(*.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)))
(*.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)))
(*.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)))
(*.f64 (pow.f64 im #s(literal 1 binary64)) im)
(*.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)))
(.f64 (/.f64 (neg.f64 im) im) (.f64 (neg.f64 im) im))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(.f64 (.f64 (neg.f64 im) im) (/.f64 (neg.f64 im) im))
(.f64 (neg.f64 im) (.f64 im (/.f64 (neg.f64 im) im)))
(*.f64 (neg.f64 im) (neg.f64 im))
(.f64 im (/.f64 (.f64 im im) im))
(.f64 im (.f64 (neg.f64 im) (/.f64 (neg.f64 im) im)))
(*.f64 im im)
(pow.f64 (fabs.f64 im) #s(literal 2 binary64))
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 im #s(literal 2 binary64))
(/.f64 (.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) (neg.f64 im)) (.f64 im im))
(/.f64 (.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) (.f64 (neg.f64 im) im)) (pow.f64 im #s(literal 3 binary64)))
(/.f64 (.f64 (neg.f64 im) (neg.f64 (pow.f64 im #s(literal 3 binary64)))) (.f64 im im))
(/.f64 (.f64 (.f64 (neg.f64 im) im) (.f64 (neg.f64 im) im)) (.f64 im im))
(/.f64 (.f64 (.f64 (neg.f64 im) im) (neg.f64 (pow.f64 im #s(literal 3 binary64)))) (pow.f64 im #s(literal 3 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (.f64 (.f64 im im) (.f64 im im))) (.f64 (neg.f64 im) im))
(/.f64 (-.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 0 binary64)) (.f64 im im))
(/.f64 (+.f64 (pow.f64 (.f64 im im) #s(literal 3 binary64)) #s(literal 0 binary64)) (fma.f64 (.f64 im im) (.f64 im im) (-.f64 #s(literal 0 binary64) (.f64 (*.f64 im im) #s(literal 0 binary64)))))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (.f64 im im) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 #s(literal 0 binary64) (.f64 im im)))))
(/.f64 (.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) (neg.f64 (pow.f64 im #s(literal 3 binary64)))) (.f64 (.f64 im im) (.f64 im im)))
(/.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) (neg.f64 im))
(/.f64 (pow.f64 im #s(literal 3 binary64)) (neg.f64 (neg.f64 im)))
(/.f64 (pow.f64 im #s(literal 3 binary64)) im)
(neg.f64 (/.f64 (pow.f64 im #s(literal 3 binary64)) (neg.f64 im)))
(neg.f64 (.f64 (.f64 im im) (/.f64 (neg.f64 im) im)))
(neg.f64 (*.f64 (neg.f64 im) im))
(fma.f64 (/.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) (*.f64 (neg.f64 im) im)) im #s(literal 0 binary64))
(fma.f64 (/.f64 (neg.f64 (pow.f64 im #s(literal 3 binary64))) (neg.f64 (pow.f64 im #s(literal 3 binary64)))) (*.f64 im im) #s(literal 0 binary64))
(fma.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)) #s(literal 0 binary64))
(fma.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)) #s(literal 0 binary64))
(fma.f64 (pow.f64 im #s(literal 1 binary64)) (pow.f64 im #s(literal 1 binary64)) #s(literal 0 binary64))
(fma.f64 (pow.f64 im #s(literal 1 binary64)) im #s(literal 0 binary64))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) #s(literal 0 binary64))
(fma.f64 (/.f64 (neg.f64 im) im) (*.f64 (neg.f64 im) im) #s(literal 0 binary64))
(fma.f64 (fabs.f64 im) (fabs.f64 im) #s(literal 0 binary64))
(fma.f64 (*.f64 (neg.f64 im) im) (/.f64 (neg.f64 im) im) #s(literal 0 binary64))
(fma.f64 (neg.f64 im) (*.f64 im (/.f64 (neg.f64 im) im)) #s(literal 0 binary64))
(fma.f64 (neg.f64 im) (neg.f64 im) #s(literal 0 binary64))
(fma.f64 im (/.f64 (*.f64 im im) im) #s(literal 0 binary64))
(fma.f64 im (*.f64 (neg.f64 im) (/.f64 (neg.f64 im) im)) #s(literal 0 binary64))
(fma.f64 im im #s(literal 0 binary64))
(-.f64 (*.f64 im im) #s(literal 0 binary64))
(fabs.f64 (*.f64 im im))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(+.f64 (*.f64 im im) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (*.f64 im im))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (.f64 im im) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))) re)))
#s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (.f64 im im) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im #s(literal 1/2 binary64)) im #s(literal 1 binary64))) re))
(/.f64 (-.f64 #s(literal 1/144 binary64) (pow.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 1/12 binary64) (.f64 (.f64 im im) #s(literal 1/360 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 2 binary64)) #s(literal 1/144 binary64))) (neg.f64 (-.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 1/12 binary64))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 im im) #s(literal 3 binary64)) #s(literal 1/46656000 binary64) #s(literal 1/1728 binary64))) (neg.f64 (-.f64 (+.f64 (pow.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 2 binary64)) #s(literal 1/144 binary64)) (.f64 (*.f64 im im) #s(literal 1/4320 binary64)))))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 2 binary64)) #s(literal 1/144 binary64)) (-.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 1/12 binary64)))
(/.f64 (fma.f64 (pow.f64 (.f64 im im) #s(literal 3 binary64)) #s(literal 1/46656000 binary64) #s(literal 1/1728 binary64)) (+.f64 #s(literal 1/144 binary64) (-.f64 (pow.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 2 binary64)) (.f64 (*.f64 im im) #s(literal 1/4320 binary64)))))
(/.f64 (fma.f64 (pow.f64 (.f64 im im) #s(literal 3 binary64)) #s(literal 1/46656000 binary64) #s(literal 1/1728 binary64)) (-.f64 (+.f64 (pow.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 2 binary64)) #s(literal 1/144 binary64)) (.f64 (*.f64 im im) #s(literal 1/4320 binary64))))
(fma.f64 (*.f64 #s(literal 1/360 binary64) (fabs.f64 im)) (fabs.f64 im) #s(literal 1/12 binary64))
(fma.f64 (*.f64 #s(literal 1/360 binary64) (neg.f64 im)) (neg.f64 im) #s(literal 1/12 binary64))
(fma.f64 (*.f64 #s(literal 1/360 binary64) im) im #s(literal 1/12 binary64))
(fma.f64 (fabs.f64 im) (*.f64 (fabs.f64 im) #s(literal 1/360 binary64)) #s(literal 1/12 binary64))
(fma.f64 (neg.f64 im) (*.f64 (neg.f64 im) #s(literal 1/360 binary64)) #s(literal 1/12 binary64))
(fma.f64 (*.f64 im im) #s(literal 1/360 binary64) #s(literal 1/12 binary64))
(fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64))
(fma.f64 im (*.f64 #s(literal 1/360 binary64) im) #s(literal 1/12 binary64))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 1/12 binary64))) (/.f64 #s(literal 1/144 binary64) (-.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 1/12 binary64))))
(-.f64 #s(literal 1/12 binary64) (.f64 (neg.f64 (.f64 #s(literal 1/360 binary64) im)) im))
(-.f64 #s(literal 1/12 binary64) (.f64 (.f64 (neg.f64 im) im) #s(literal 1/360 binary64)))
(-.f64 #s(literal 1/12 binary64) (.f64 #s(literal -1/360 binary64) (.f64 im im)))
(+.f64 (/.f64 (pow.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 3 binary64)) (-.f64 (+.f64 (pow.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 2 binary64)) #s(literal 1/144 binary64)) (.f64 (.f64 im im) #s(literal 1/4320 binary64)))) (/.f64 #s(literal 1/1728 binary64) (-.f64 (+.f64 (pow.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 2 binary64)) #s(literal 1/144 binary64)) (.f64 (.f64 im im) #s(literal 1/4320 binary64)))))
(+.f64 (.f64 (.f64 im im) #s(literal 1/360 binary64)) #s(literal 1/12 binary64))
(+.f64 #s(literal 1/12 binary64) (.f64 (.f64 im im) #s(literal 1/360 binary64)))
(.f64 (fma.f64 #s(literal -1/12 binary64) (.f64 im im) #s(literal -1/6 binary64)) re)
(.f64 re (fma.f64 #s(literal -1/12 binary64) (.f64 im im) #s(literal -1/6 binary64)))
(/.f64 (.f64 (-.f64 (pow.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) #s(literal 2 binary64)) #s(literal 1/36 binary64)) re) (-.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) #s(literal -1/6 binary64)))
(/.f64 (.f64 (fma.f64 #s(literal -1/1728 binary64) (pow.f64 (.f64 im im) #s(literal 3 binary64)) #s(literal -1/216 binary64)) re) (-.f64 (+.f64 (pow.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) #s(literal 2 binary64)) #s(literal 1/36 binary64)) (.f64 (.f64 im im) #s(literal 1/72 binary64))))
(/.f64 (.f64 re (-.f64 (pow.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) #s(literal 2 binary64)) #s(literal 1/36 binary64))) (-.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) #s(literal -1/6 binary64)))
(/.f64 (.f64 re (fma.f64 #s(literal -1/1728 binary64) (pow.f64 (.f64 im im) #s(literal 3 binary64)) #s(literal -1/216 binary64))) (-.f64 (+.f64 (pow.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) #s(literal 2 binary64)) #s(literal 1/36 binary64)) (.f64 (.f64 im im) #s(literal 1/72 binary64))))
(fma.f64 (.f64 #s(literal -1/12 binary64) im) (.f64 im re) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (.f64 #s(literal -1/12 binary64) im) (.f64 im re) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 (.f64 #s(literal -1/12 binary64) re) (.f64 im im) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (.f64 #s(literal -1/12 binary64) re) (.f64 im im) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 (fabs.f64 im) (.f64 (fabs.f64 im) (.f64 #s(literal -1/12 binary64) re)) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (fabs.f64 im) (.f64 (fabs.f64 im) (.f64 #s(literal -1/12 binary64) re)) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 (neg.f64 im) (.f64 (neg.f64 im) (.f64 #s(literal -1/12 binary64) re)) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (neg.f64 im) (.f64 (neg.f64 im) (.f64 #s(literal -1/12 binary64) re)) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 (.f64 (.f64 im re) im) #s(literal -1/12 binary64) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (.f64 (.f64 im re) im) #s(literal -1/12 binary64) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 #s(literal -1/6 binary64) re (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re))
(fma.f64 #s(literal -1/12 binary64) (.f64 (.f64 im re) im) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 #s(literal -1/12 binary64) (.f64 (.f64 im re) im) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 (.f64 im im) (.f64 #s(literal -1/12 binary64) re) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (.f64 im im) (.f64 #s(literal -1/12 binary64) re) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 im (.f64 (.f64 im re) #s(literal -1/12 binary64)) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 im (.f64 (.f64 im re) #s(literal -1/12 binary64)) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 im (.f64 im (.f64 #s(literal -1/12 binary64) re)) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 im (.f64 im (.f64 #s(literal -1/12 binary64) re)) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 re (.f64 #s(literal -1/12 binary64) (.f64 im im)) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 re (.f64 #s(literal -1/12 binary64) (.f64 im im)) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 re #s(literal -1/6 binary64) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re))
(+.f64 (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re) (.f64 #s(literal -1/6 binary64) re))
(+.f64 (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re) (.f64 re #s(literal -1/6 binary64)))
(+.f64 (.f64 #s(literal -1/6 binary64) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re))
(+.f64 (.f64 re #s(literal -1/6 binary64)) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re))
#s(approx (* (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re))
(.f64 (.f64 re (fabs.f64 im)) (fabs.f64 im))
(.f64 (.f64 re (neg.f64 im)) (neg.f64 im))
(.f64 (fabs.f64 im) (.f64 (fabs.f64 im) re))
(.f64 (neg.f64 im) (.f64 (neg.f64 im) re))
(.f64 (.f64 im re) im)
(.f64 (.f64 im im) re)
(.f64 im (.f64 im re))
(.f64 re (.f64 im im))
(.f64 (fma.f64 #s(literal -1/12 binary64) (.f64 im im) #s(literal -1/6 binary64)) re)
(.f64 re (fma.f64 #s(literal -1/12 binary64) (.f64 im im) #s(literal -1/6 binary64)))
(/.f64 (.f64 (-.f64 (pow.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) #s(literal 2 binary64)) #s(literal 1/36 binary64)) re) (-.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) #s(literal -1/6 binary64)))
(/.f64 (.f64 (fma.f64 #s(literal -1/1728 binary64) (pow.f64 (.f64 im im) #s(literal 3 binary64)) #s(literal -1/216 binary64)) re) (-.f64 (+.f64 (pow.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) #s(literal 2 binary64)) #s(literal 1/36 binary64)) (.f64 (.f64 im im) #s(literal 1/72 binary64))))
(/.f64 (.f64 re (-.f64 (pow.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) #s(literal 2 binary64)) #s(literal 1/36 binary64))) (-.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) #s(literal -1/6 binary64)))
(/.f64 (.f64 re (fma.f64 #s(literal -1/1728 binary64) (pow.f64 (.f64 im im) #s(literal 3 binary64)) #s(literal -1/216 binary64))) (-.f64 (+.f64 (pow.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) #s(literal 2 binary64)) #s(literal 1/36 binary64)) (.f64 (.f64 im im) #s(literal 1/72 binary64))))
(fma.f64 (.f64 #s(literal -1/12 binary64) im) (.f64 im re) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (.f64 #s(literal -1/12 binary64) im) (.f64 im re) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 (.f64 #s(literal -1/12 binary64) re) (.f64 im im) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (.f64 #s(literal -1/12 binary64) re) (.f64 im im) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 (fabs.f64 im) (.f64 (fabs.f64 im) (.f64 #s(literal -1/12 binary64) re)) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (fabs.f64 im) (.f64 (fabs.f64 im) (.f64 #s(literal -1/12 binary64) re)) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 (neg.f64 im) (.f64 (neg.f64 im) (.f64 #s(literal -1/12 binary64) re)) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (neg.f64 im) (.f64 (neg.f64 im) (.f64 #s(literal -1/12 binary64) re)) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 (.f64 (.f64 im re) im) #s(literal -1/12 binary64) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (.f64 (.f64 im re) im) #s(literal -1/12 binary64) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 #s(literal -1/6 binary64) re (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re))
(fma.f64 #s(literal -1/12 binary64) (.f64 (.f64 im re) im) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 #s(literal -1/12 binary64) (.f64 (.f64 im re) im) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 (.f64 im im) (.f64 #s(literal -1/12 binary64) re) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 (.f64 im im) (.f64 #s(literal -1/12 binary64) re) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 im (.f64 (.f64 im re) #s(literal -1/12 binary64)) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 im (.f64 (.f64 im re) #s(literal -1/12 binary64)) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 im (.f64 im (.f64 #s(literal -1/12 binary64) re)) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 im (.f64 im (.f64 #s(literal -1/12 binary64) re)) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 re (.f64 #s(literal -1/12 binary64) (.f64 im im)) (*.f64 #s(literal -1/6 binary64) re))
(fma.f64 re (.f64 #s(literal -1/12 binary64) (.f64 im im)) (*.f64 re #s(literal -1/6 binary64)))
(fma.f64 re #s(literal -1/6 binary64) (.f64 (.f64 #s(literal -1/12 binary64) (*.f64 im im)) re))
(+.f64 (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re) (.f64 #s(literal -1/6 binary64) re))
(+.f64 (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re) (.f64 re #s(literal -1/6 binary64)))
(+.f64 (.f64 #s(literal -1/6 binary64) re) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re))
(+.f64 (.f64 re #s(literal -1/6 binary64)) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 im im)) re))

eval38.0ms (0.5%)

Memory: 31.2MiB live, 76.9MiB allocated; 4ms collecting garbage
Compiler: Compiled 14 930 to 1 643 computations (89% saved)

prune32.0ms (0.5%)

Memory

-33.0MiB live, 63.0MiB allocated; 12ms collecting garbage

Pruning

24 alts after pruning (20 fresh and 4 done)

	Pruned	Kept	Total
New	269	7	276
Fresh	5	13	18
Picked	4	1	5
Done	0	3	3
Total	278	24	302

Accuracy

100.0%

Counts

302 → 24

Alt Table

Click to see full alt table

Status	Accuracy	Program
	55.9%	(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))
	62.7%	(.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (*.f64 re re) #s(literal 1 binary64)) re))) #s(literal 1/2 binary64))
	58.1%	(.f64 #s(approx ( 1/2 (sin re)) (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))
	65.5%	(.f64 #s(approx ( 1/2 (sin re)) (*.f64 #s(literal 1/2 binary64) re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)))))
	60.5%	(.f64 #s(approx ( 1/2 (sin re)) (.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))
✓	76.3%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re)))
✓	51.8%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (fma.f64 (.f64 re (.f64 re re)) (-.f64 (.f64 (.f64 (fma.f64 #s(literal -1/5040 binary64) (*.f64 re re) #s(literal 1/120 binary64)) re) re) #s(literal 1/6 binary64)) re))))
	55.1%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (fma.f64 (.f64 re (.f64 re re)) (-.f64 (.f64 #s(approx ( (+ (* -1/5040 (* re re)) 1/120) re) (*.f64 #s(literal 1/120 binary64) re)) re) #s(literal 1/6 binary64)) re))))
	56.0%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 #s(approx (+ ( (* 1/2 im) im) 1) #s(literal 1 binary64)) (sin.f64 re)))
	36.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re (.f64 (.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64)) re) re) re))))
	52.2%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re (*.f64 #s(literal 1 binary64) re))))
	54.7%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (/.f64 (.f64 (*.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)))
✓	52.2%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)))
	42.2%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im re) im) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
	37.9%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (fma.f64 (*.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64))) re)))
	11.1%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) im) (.f64 im re) (.f64 re #s(literal -1/6 binary64))) re)) re)))
	22.3%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im)) re)))
	11.2%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (*.f64 im im) #s(literal -1/12 binary64)) re)) re)) re)))
	9.0%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (*.f64 #s(literal -1/6 binary64) re)) re)) re)))
	23.8%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* im im) 1/2) 1) (.f64 (.f64 im im) #s(literal 1/2 binary64))) re)))
	16.8%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal -1/12 binary64) (.f64 #s(literal 1/2 binary64) im)) re)) im)))
✓	18.3%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)))
	16.6%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) #s(approx (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (.f64 (.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re) im) im))))
	29.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) #s(approx (* (+ (* (* im im) 1/2) 1) re) (.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) re (/.f64 re (*.f64 im im))) im) im))))

Compiler

Compiled 2 686 to 980 computations (63.5% saved)

regimes66.0ms (0.9%)

Memory

34.1MiB live, 126.7MiB allocated; 5ms collecting garbage

Counts

42 → 1

Calls

Call 1

Inputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* im im) 1/2) 1) (.f64 (.f64 im im) #s(literal 1/2 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (*.f64 #s(literal -1/6 binary64) re)) re)) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (fma.f64 #s(literal -1/6 binary64) (*.f64 re re) #s(literal 1 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (fma.f64 (*.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re (*.f64 #s(literal 1 binary64) re))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (*.f64 im im) #s(literal -1/12 binary64)) re)) re)) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) #s(approx (* (+ (* (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) re) (.f64 (.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re) im) im))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im)) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal -1/12 binary64) (.f64 #s(literal 1/2 binary64) im)) re)) im)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) im) (.f64 im re) (.f64 re #s(literal -1/6 binary64))) re)) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) #s(approx (* (+ (* (* im im) 1/2) 1) re) (.f64 (.f64 (fma.f64 #s(literal 1/2 binary64) re (/.f64 re (*.f64 im im))) im) im))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (/.f64 (.f64 (*.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) re) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im re) im) #s(literal -1/12 binary64))) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re (.f64 (.f64 (.f64 (fma.f64 #s(literal -1/12 binary64) (*.f64 im im) #s(literal -1/6 binary64)) re) re) re))))
(.f64 #s(approx ( 1/2 (sin re)) (.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (/.f64 (-.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 0 binary64)) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (.f64 (fma.f64 (-.f64 (.f64 #s(literal 1/120 binary64) (.f64 re re)) #s(literal 1/6 binary64)) (.f64 re re) #s(literal 1 binary64)) re))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (fma.f64 (.f64 re (.f64 re re)) (-.f64 (.f64 #s(approx ( (+ (* -1/5040 (* re re)) 1/120) re) (*.f64 #s(literal 1/120 binary64) re)) re) #s(literal 1/6 binary64)) re))))
(.f64 #s(approx ( 1/2 (sin re)) (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (fma.f64 (.f64 re (.f64 re re)) (-.f64 (.f64 (.f64 (fma.f64 #s(literal -1/5040 binary64) (*.f64 re re) #s(literal 1/120 binary64)) re) re) #s(literal 1/6 binary64)) re))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (fma.f64 (.f64 re (.f64 re re)) (-.f64 (.f64 (fma.f64 #s(literal -1/5040 binary64) (.f64 re re) #s(literal 1/120 binary64)) (*.f64 re re)) #s(literal 1/6 binary64)) re))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 (fma.f64 (/.f64 (.f64 (.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (-.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) im) im (/.f64 (/.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re) re)) #s(literal 1/6 binary64)) (.f64 re re))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 #s(approx (+ ( (* 1/2 im) im) 1) #s(literal 1 binary64)) (sin.f64 re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) im) im)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re)))
(.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (*.f64 re re) #s(literal 1 binary64)) re))) #s(literal 1/2 binary64))
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 #s(literal 1/12 binary64) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64))))
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
(.f64 #s(approx ( 1/2 (sin re)) (*.f64 #s(literal 1/2 binary64) re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)))))
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)))))
(/.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 (.f64 #s(literal 3 binary64) im))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (+.f64 (expm1.f64 (+.f64 im im)) (exp.f64 (*.f64 im #s(literal -2 binary64)))))
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 (-.f64 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (sinh.f64 im) (sinh.f64 im))) (exp.f64 (neg.f64 im)))))
(/.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (exp.f64 (.f64 (neg.f64 im) #s(literal 3 binary64)))) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (fma.f64 (exp.f64 im) (-.f64 (exp.f64 im) (exp.f64 (neg.f64 im))) (exp.f64 (.f64 (neg.f64 im) #s(literal 2 binary64)))))

Outputs
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)))))

Calls

6 calls:

12.0ms	(sin.f64 re)
12.0ms	re
11.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
11.0ms	im
10.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

Results

Accuracy	Segments	Branch
100.0%	1	`(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))`
100.0%	1	`(sin.f64 re)`
100.0%	1	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
100.0%	1	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`
100.0%	1	`re`
100.0%	1	`im`

Compiler

Compiled 27 to 30 computations (-11.1% saved)

regimes64.0ms (0.9%)

Memory

-0.2MiB live, 92.2MiB allocated; 12ms collecting garbage

Counts

38 → 1

Calls

Call 1

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

Outputs
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))

Calls

6 calls:

15.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
11.0ms	im
10.0ms	(sin.f64 re)
10.0ms	re
9.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

Results

Accuracy	Segments	Branch
100.0%	1	`(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))`
100.0%	1	`(sin.f64 re)`
100.0%	1	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
100.0%	1	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`
100.0%	1	`re`
100.0%	1	`im`

Compiler

Compiled 27 to 30 computations (-11.1% saved)

regimes64.0ms (0.9%)

Memory

-0.9MiB live, 87.9MiB allocated; 13ms collecting garbage

Counts

35 → 3

Calls

Call 1

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

Outputs

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

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

(*.f64 (*.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64)) (*.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))

Calls

6 calls:

13.0ms	(sin.f64 re)
13.0ms	im
11.0ms	re
9.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
8.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

Results

Accuracy	Segments	Branch
91.4%	1	`(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))`
95.6%	3	`(sin.f64 re)`
95.6%	3	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
93.6%	2	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`
95.6%	2	`re`
97.7%	3	`im`

Compiler

Compiled 27 to 30 computations (-11.1% saved)

regimes24.0ms (0.3%)

Memory

-7.7MiB live, 36.7MiB allocated; 6ms collecting garbage

Counts

34 → 3

Calls

Call 1

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

Outputs

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

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

(*.f64 (*.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 #s(literal 1/12 binary64) (*.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))

Calls

2 calls:

13.0ms	re
9.0ms	im

Results

Accuracy	Segments	Branch
93.8%	2	`re`
96.6%	3	`im`

Compiler

Compiled 2 to 4 computations (-100% saved)

regimes53.0ms (0.8%)

Memory

32.1MiB live, 81.8MiB allocated; 15ms collecting garbage

Counts

33 → 3

Calls

Call 1

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

Outputs

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

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

(*.f64 #s(approx (* 1/2 (sin re)) (*.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64)) (*.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))

Calls

5 calls:

17.0ms	(sin.f64 re)
9.0ms	re
9.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
9.0ms	im
8.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

Results

Accuracy	Segments	Branch
94.9%	3	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`
86.7%	2	`re`
86.7%	3	`(sin.f64 re)`
86.7%	3	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
94.2%	4	`im`

Compiler

Compiled 20 to 23 computations (-15% saved)

regimes23.0ms (0.3%)

Memory

-12.3MiB live, 32.4MiB allocated; 10ms collecting garbage

Counts

32 → 3

Calls

Call 1

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

Outputs

(*.f64 #s(approx (* 1/2 (sin re)) (*.f64 (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64)) (*.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))

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

(*.f64 #s(approx (* 1/2 (sin re)) (*.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64)) (*.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))

Calls

2 calls:

8.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))
6.0ms	(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))

Results

Accuracy	Segments	Branch
84.5%	2	`(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))`
94.5%	3	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`

Compiler

Compiled 19 to 18 computations (5.3% saved)

regimes14.0ms (0.2%)

Memory

-26.2MiB live, 19.3MiB allocated; 8ms collecting garbage

Counts

31 → 3

Calls

Call 1

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

Outputs

(*.f64 #s(approx (* 1/2 (sin re)) (*.f64 (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64)) (*.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))

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

(*.f64 #s(approx (* 1/2 (sin re)) (*.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64)) (*.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))

Calls

1 calls:

12.0ms

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

Results

Accuracy	Segments	Branch
94.1%	3	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`

Compiler

Compiled 12 to 11 computations (8.3% saved)

regimes49.0ms (0.7%)

Memory

37.5MiB live, 83.4MiB allocated; 4ms collecting garbage

Counts

29 → 2

Calls

Call 1

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

Outputs

(*.f64 #s(approx (* 1/2 (sin re)) (*.f64 (fma.f64 (*.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64)) (*.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))

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

Calls

6 calls:

11.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
8.0ms	(sin.f64 re)
8.0ms	re
8.0ms	im
7.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

Results

Accuracy	Segments	Branch
60.5%	1	`(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))`
71.5%	2	`(sin.f64 re)`
71.5%	2	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
62.8%	2	`re`
60.5%	1	`im`
71.1%	2	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`

Compiler

Compiled 27 to 30 computations (-11.1% saved)

regimes29.0ms (0.4%)

Memory

-27.0MiB live, 35.1MiB allocated; 21ms collecting garbage

Counts

24 → 2

Calls

Call 1

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

Outputs

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

(*.f64 #s(approx (* 1/2 (sin re)) (*.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (*.f64 im im) #s(literal 1/12 binary64)) (*.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))

Calls

3 calls:

15.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
7.0ms	(sin.f64 re)
6.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

Results

Accuracy	Segments	Branch
69.7%	2	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`
69.7%	2	`(sin.f64 re)`
69.7%	2	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`

Compiler

Compiled 18 to 19 computations (-5.6% saved)

regimes22.0ms (0.3%)

Memory

-13.5MiB live, 31.8MiB allocated; 7ms collecting garbage

Counts

20 → 2

Calls

Call 1

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

Outputs

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

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

Calls

3 calls:

9.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))
6.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
6.0ms	(sin.f64 re)

Results

Accuracy	Segments	Branch
63.8%	2	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`
63.8%	2	`(sin.f64 re)`
63.8%	2	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`

Compiler

Compiled 18 to 19 computations (-5.6% saved)

regimes30.0ms (0.4%)

Memory

9.8MiB live, 54.8MiB allocated; 6ms collecting garbage

Counts

15 → 2

Calls

Call 1

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

Outputs

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

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

Calls

6 calls:

7.0ms	(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))
5.0ms	(sin.f64 re)
5.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
4.0ms	im
4.0ms	re

Results

Accuracy	Segments	Branch
54.0%	2	`im`
52.2%	1	`(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))`
52.2%	1	`re`
61.3%	2	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`
61.3%	2	`(sin.f64 re)`
61.3%	2	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`

Compiler

Compiled 27 to 30 computations (-11.1% saved)

regimes12.0ms (0.2%)

Memory

30.8MiB live, 30.8MiB allocated; 0ms collecting garbage

Counts

11 → 2

Calls

Call 1

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

Outputs

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

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

Calls

3 calls:

4.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
4.0ms	(sin.f64 re)
3.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

Results

Accuracy	Segments	Branch
61.3%	2	`(sin.f64 re)`
61.3%	2	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
61.3%	2	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`

Compiler

Compiled 18 to 19 computations (-5.6% saved)

regimes14.0ms (0.2%)

Memory

-18.9MiB live, 27.3MiB allocated; 5ms collecting garbage

Counts

10 → 2

Calls

Call 1

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

Outputs

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

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

Calls

3 calls:

6.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))
3.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
3.0ms	(sin.f64 re)

Results

Accuracy	Segments	Branch
61.2%	2	`(sin.f64 re)`
61.2%	2	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
61.2%	2	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`

Compiler

Compiled 18 to 19 computations (-5.6% saved)

regimes10.0ms (0.1%)

Memory

20.9MiB live, 20.9MiB allocated; 0ms collecting garbage

Counts

9 → 2

Calls

Call 1

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

Outputs

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

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

Calls

3 calls:

3.0ms	(sin.f64 re)
3.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
3.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

Results

Accuracy	Segments	Branch
61.2%	2	`(sin.f64 re)`
61.2%	2	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
61.2%	2	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`

Compiler

Compiled 18 to 19 computations (-5.6% saved)

regimes27.0ms (0.4%)

Memory

-31.5MiB live, 19.1MiB allocated; 10ms collecting garbage

Counts

7 → 2

Calls

Call 1

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

Outputs

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

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

Calls

3 calls:

20.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))
3.0ms	(sin.f64 re)
3.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))

Results

Accuracy	Segments	Branch
59.0%	2	`(sin.f64 re)`
59.0%	2	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
59.0%	2	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`

Compiler

Compiled 18 to 19 computations (-5.6% saved)

regimes3.0ms (0%)

Memory

6.3MiB live, 6.3MiB allocated; 0ms collecting garbage

Counts

6 → 2

Calls

Call 1

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

Outputs

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

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

Calls

1 calls:

2.0ms

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

Results

Accuracy	Segments	Branch
59.0%	2	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`

Compiler

Compiled 12 to 11 computations (8.3% saved)

regimes7.0ms (0.1%)

Memory

16.5MiB live, 16.5MiB allocated; 0ms collecting garbage

Counts

5 → 2

Calls

Call 1

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

Outputs

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

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

Calls

3 calls:

2.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
2.0ms	(sin.f64 re)
2.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))

Results

Accuracy	Segments	Branch
48.5%	2	`(sin.f64 re)`
48.5%	2	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
58.6%	2	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`

Compiler

Compiled 18 to 19 computations (-5.6% saved)

regimes17.0ms (0.2%)

Memory

-18.0MiB live, 28.3MiB allocated; 4ms collecting garbage

Counts

3 → 2

Calls

Call 1

Inputs

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

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

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

Outputs

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

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

Calls

6 calls:

8.0ms	im
2.0ms	(sin.f64 re)
2.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
2.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))
2.0ms	re

Results

Accuracy	Segments	Branch
30.4%	2	`(sin.f64 re)`
30.4%	2	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
23.8%	1	`re`
23.8%	1	`(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))`
23.8%	1	`im`
30.4%	2	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`

Compiler

Compiled 27 to 30 computations (-11.1% saved)

regimes5.0ms (0.1%)

Memory

14.9MiB live, 14.9MiB allocated; 0ms collecting garbage

Counts

2 → 1

Calls

Call 1

Inputs

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

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

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

Calls

3 calls:

1.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
1.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))
1.0ms	(sin.f64 re)

Results

Accuracy	Segments	Branch
23.8%	1	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`
23.8%	1	`(sin.f64 re)`
23.8%	1	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`

Compiler

Compiled 18 to 19 computations (-5.6% saved)

regimes35.0ms (0.5%)

Memory

-26.2MiB live, 20.8MiB allocated; 3ms collecting garbage

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

1 → 1

Calls

Call 1

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

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

Calls

6 calls:

29.0ms	(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))
1.0ms	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))
1.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
1.0ms	im
1.0ms	(sin.f64 re)

Results

Accuracy	Segments	Branch
18.3%	1	`re`
18.3%	1	`im`
18.3%	1	`(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))`
18.3%	1	`(sin.f64 re)`
18.3%	1	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
18.3%	1	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`

Compiler

Compiled 27 to 30 computations (-11.1% saved)

bsearch39.0ms (0.5%)

Memory

25.2MiB live, 70.5MiB allocated; 5ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
20.0ms	8.268780879078683e+45	7.776018264604483e+49
15.0ms	4.201770314900744e-5	0.0013476609775399321

Samples

21.0ms

240×

valid

Compiler

Compiled 775 to 613 computations (20.9% saved)

Precisions

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

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

ival-exp: 3.0ms (20.4% of total)

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

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

ival-sub: 1.0ms (6.8% of total)

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

bsearch20.0ms (0.3%)

Memory

1.2MiB live, 54.0MiB allocated; 5ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
17.0ms	1.5752906733944908e+75	2.7967657731355854e+76
1.0ms	4.201770314900744e-5	0.0013476609775399321

Samples

12.0ms

112×

valid

Compiler

Compiled 680 to 555 computations (18.4% saved)

Precisions

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

ival-exp: 4.0ms (44.3% of total)

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

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

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

adjust: 0.0ms (0% of total)

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

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

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

exact: 0.0ms (0% of total)

bsearch1.0ms (0%)

Memory

1.8MiB live, 1.8MiB allocated; 0ms collecting garbage

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	0.9994181187401244	+inf
0.0ms	-inf	-0.9965377353440812

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch1.0ms (0%)

Memory

1.5MiB live, 1.5MiB allocated; 0ms collecting garbage

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	0.9994181187401244	+inf
0.0ms	-inf	-0.9965377353440812

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch1.0ms (0%)

Memory

1.5MiB live, 1.5MiB allocated; 0ms collecting garbage

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	0.9994181187401244	+inf
0.0ms	-inf	-0.9965377353440812

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch0.0ms (0%)

Memory

1.0MiB live, 1.0MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	7.2693078363675344e-6	0.0006423751125121252

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch0.0ms (0%)

Memory

1.2MiB live, 1.2MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.02290217295722537	1.5899091178162364e-307

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch0.0ms (0%)

Memory

1.1MiB live, 1.1MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.02290217295722537	1.5899091178162364e-307

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch0.0ms (0%)

Memory

1.7MiB live, 1.7MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.10158640865711396	3.1798182356324728e-307

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch2.0ms (0%)

Memory

-43.6MiB live, 1.7MiB allocated; 4ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
2.0ms	-0.10158640865711396	3.1798182356324728e-307

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch1.0ms (0%)

Memory

1.8MiB live, 1.8MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.10158640865711396	3.1798182356324728e-307

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch0.0ms (0%)

Memory

1.0MiB live, 1.0MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.10158640865711396	3.1798182356324728e-307

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch0.0ms (0%)

Memory

0.9MiB live, 0.9MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.10158640865711396	3.1798182356324728e-307

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch0.0ms (0%)

Memory

1.1MiB live, 1.1MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-0.10158640865711396	3.1798182356324728e-307

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch0.0ms (0%)

Memory

1.0MiB live, 1.0MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	0.25810604042528223	0.505164611093417

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch0.0ms (0%)

Memory

1.2MiB live, 1.2MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	6.943255083308169e-301	1.1517497027168341e-300

Compiler

Compiled 15 to 16 computations (-6.7% saved)

simplify67.0ms (0.9%)

Memory

24.6MiB live, 117.5MiB allocated; 4ms collecting garbage

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	199	1675
1	286	1648
2	651	1646
3	4343	1646

Stop Event

1×	node limit

Calls

Call 1

Inputs
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)))))
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
(if (<=.f64 im #s(literal 760928193040519/576460752303423488 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))) (if (<=.f64 im #s(literal 75999999999999997490950105574109916855379251167232 binary64)) (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re))) #s(literal 1/2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))))
(if (<=.f64 im #s(literal 760928193040519/576460752303423488 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))) (if (<=.f64 im #s(literal 27500000000000000490684676507905275930807857701051933340664954329573768560640 binary64)) (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re))) #s(literal 1/2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 #s(literal 1/12 binary64) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64))))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -inf.0 binary64)) (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re))) #s(literal 1/2 binary64)) (if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal 1 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))) (.f64 #s(approx ( 1/2 (sin re)) (.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -inf.0 binary64)) (.f64 #s(approx ( 1/2 (sin re)) (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64)))) (if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal 1 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))) (.f64 #s(approx ( 1/2 (sin re)) (.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -inf.0 binary64)) (.f64 #s(approx ( 1/2 (sin re)) (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64)))) (if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal 1 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 #s(approx (+ ( (* 1/2 im) im) 1) #s(literal 1 binary64)) (sin.f64 re))) (.f64 #s(approx ( 1/2 (sin re)) (.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))))
(if (<=.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(literal 5902958103587057/590295810358705651712 binary64)) (.f64 #s(approx (* 1/2 (sin re)) (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64)))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (.f64 (fma.f64 (-.f64 (.f64 #s(literal 1/120 binary64) (.f64 re re)) #s(literal 1/6 binary64)) (.f64 re re) #s(literal 1 binary64)) re)))))
(if (<=.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(literal -5764607523034235/288230376151711744 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal -1/12 binary64) (.f64 #s(literal 1/2 binary64) im)) re)) im))) (.f64 #s(approx ( 1/2 (sin re)) (.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))))
(if (<=.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(literal -5764607523034235/288230376151711744 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal -1/12 binary64) (.f64 #s(literal 1/2 binary64) im)) re)) im))) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (/.f64 (.f64 (*.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal -1/12 binary64) (.f64 #s(literal 1/2 binary64) im)) re)) im))) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re (*.f64 #s(literal 1 binary64) re)))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re (*.f64 #s(literal 1 binary64) re)))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re (*.f64 #s(literal 1 binary64) re)))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) #s(literal -1/12 binary64)) re)) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re (*.f64 #s(literal 1 binary64) re)))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 #s(literal -1/6 binary64) re)) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re (*.f64 #s(literal 1 binary64) re)))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 #s(literal -1/6 binary64) re)) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal 1/2 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64))) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* im im) 1/2) 1) (.f64 (.f64 im im) #s(literal 1/2 binary64))) re))))
(if (<=.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(literal 6032057205060441/6032057205060440848842124543157735677050252251748505781796615064961622344493727293370973578138265743708225425014400837164813540499979063179105919597766951022193355091707896034850684039059079180396788349106095584290087446076413771468940477241550670753145517602931224392424029547429993824129889235158145614364972941312 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 #s(literal -1/6 binary64) re)) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* im im) 1/2) 1) (.f64 (.f64 im im) #s(literal 1/2 binary64))) re))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* im im) 1/2) 1) (.f64 (.f64 im im) #s(literal 1/2 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)))

Outputs
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)))))
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 im)))))
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
(if (<=.f64 im #s(literal 760928193040519/576460752303423488 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))) (if (<=.f64 im #s(literal 75999999999999997490950105574109916855379251167232 binary64)) (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re))) #s(literal 1/2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))))
(if (<=.f64 im #s(literal 760928193040519/576460752303423488 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))) (if (<=.f64 im #s(literal 27500000000000000490684676507905275930807857701051933340664954329573768560640 binary64)) (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re))) #s(literal 1/2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 #s(literal 1/12 binary64) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64))))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -inf.0 binary64)) (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re))) #s(literal 1/2 binary64)) (if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal 1 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))) (.f64 #s(approx ( 1/2 (sin re)) (.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) #s(literal -inf.0 binary64)) (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re))) #s(literal 1/2 binary64)) (if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) #s(literal 1 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))) (.f64 #s(approx ( 1/2 (sin re)) (.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -inf.0 binary64)) (.f64 #s(approx ( 1/2 (sin re)) (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64)))) (if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal 1 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))) (.f64 #s(approx ( 1/2 (sin re)) (.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) #s(literal -inf.0 binary64)) (.f64 #s(approx ( 1/2 (sin re)) (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64)))) (if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) #s(literal 1 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) (sin.f64 re))) (.f64 #s(approx ( 1/2 (sin re)) (.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -inf.0 binary64)) (.f64 #s(approx ( 1/2 (sin re)) (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64)))) (if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal 1 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 #s(approx (+ ( (* 1/2 im) im) 1) #s(literal 1 binary64)) (sin.f64 re))) (.f64 #s(approx ( 1/2 (sin re)) (.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) #s(literal -inf.0 binary64)) (.f64 #s(approx ( 1/2 (sin re)) (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64)))) (if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) #s(literal 1 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 #s(approx (+ ( (* im im) 1/2) 1) #s(literal 1 binary64)) (sin.f64 re))) (.f64 #s(approx ( 1/2 (sin re)) (.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64))))))
(if (<=.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(literal 5902958103587057/590295810358705651712 binary64)) (.f64 #s(approx (* 1/2 (sin re)) (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) re)) #s(approx (+ (exp (- 0 im)) (/ (- (* (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64)))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) im) im #s(literal 1 binary64)) #s(approx (sin re) (.f64 (fma.f64 (-.f64 (.f64 #s(literal 1/120 binary64) (.f64 re re)) #s(literal 1/6 binary64)) (.f64 re re) #s(literal 1 binary64)) re)))))
(if (<=.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(literal -5764607523034235/288230376151711744 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal -1/12 binary64) (.f64 #s(literal 1/2 binary64) im)) re)) im))) (.f64 #s(approx ( 1/2 (sin re)) (.f64 #s(literal 1/2 binary64) re)) #s(approx (+ (exp (- 0 im)) (/ (- ( (cosh im) (cosh im)) (* (sinh im) (sinh im))) (exp (neg im)))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/360 binary64) (.f64 im im) #s(literal 1/12 binary64)) (.f64 im im) #s(literal 1 binary64)) (*.f64 im im) #s(literal 2 binary64)))))
(if (<=.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(literal -5764607523034235/288230376151711744 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal -1/12 binary64) (.f64 #s(literal 1/2 binary64) im)) re)) im))) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (/.f64 (.f64 (*.f64 im (neg.f64 im)) (neg.f64 im)) im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))))
(if (<=.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(literal -5764607523034235/288230376151711744 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal -1/12 binary64) (.f64 #s(literal 1/2 binary64) im)) re)) im))) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (/.f64 (.f64 (*.f64 im im) im) im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal -1/12 binary64) (.f64 #s(literal 1/2 binary64) im)) re)) im))) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re (*.f64 #s(literal 1 binary64) re)))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (fma.f64 (.f64 (.f64 re im) re) #s(literal -1/12 binary64) (.f64 #s(literal 1/2 binary64) im)) re)) im))) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re re))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re (*.f64 #s(literal 1 binary64) re)))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64)) im) im)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re re))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re (*.f64 #s(literal 1 binary64) re)))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 (.f64 (fma.f64 (.f64 im im) #s(literal -1/12 binary64) #s(literal -1/6 binary64)) re) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re re))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) #s(literal -1/12 binary64)) re)) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re (*.f64 #s(literal 1 binary64) re)))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 (.f64 (.f64 im im) #s(literal -1/12 binary64)) re)) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re re))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 #s(literal -1/6 binary64) re)) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re (*.f64 #s(literal 1 binary64) re)))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 #s(literal -1/6 binary64) re)) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) im) im) re re))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 #s(literal -1/6 binary64) re)) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) #s(literal -3602879701896397/36028797018963968 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 #s(literal -1/6 binary64) re)) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 (fma.f64 (.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))) #s(literal 1/2 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64))) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* im im) 1/2) 1) (.f64 (.f64 im im) #s(literal 1/2 binary64))) re))))
(if (<=.f64 (.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))) #s(literal 1/2 binary64)) #s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64))) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* im im) 1/2) 1) (.f64 (.f64 im im) #s(literal 1/2 binary64))) re))))
(if (<=.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) #s(literal 6032057205060441/6032057205060440848842124543157735677050252251748505781796615064961622344493727293370973578138265743708225425014400837164813540499979063179105919597766951022193355091707896034850684039059079180396788349106095584290087446076413771468940477241550670753145517602931224392424029547429993824129889235158145614364972941312 binary64)) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* (+ (* (* im im) -1/12) -1/6) re) re) (+ (* (* im im) 1/2) 1)) (.f64 #s(approx ( (+ (* (* im im) -1/12) -1/6) re) (.f64 #s(literal -1/6 binary64) re)) re)) re))) #s(approx ( (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* im im) 1/2) 1) (.f64 (.f64 im im) #s(literal 1/2 binary64))) re))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx (+ ( (* im im) 1/2) 1) (.f64 (.f64 im im) #s(literal 1/2 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (+ (* (* 1/2 im) im) 1) (sin re)) (.f64 #s(approx ( (* (sin re) 1/2) im) (.f64 (.f64 re im) #s(literal 1/2 binary64))) im)))

derivations1.3s (18.8%)

Memory

-114.5MiB live, 855.0MiB allocated; 791ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 1 799 to 199 computations (88.9% saved)

preprocess193.0ms (2.7%)

Memory

-7.9MiB live, 180.0MiB allocated; 51ms collecting garbage

Remove

(negabs re)

(abs im)

Compiler

Compiled 3 734 to 508 computations (86.4% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated; 0ms collecting garbage

start0.0ms (0%)

analyze0.0ms (0%)

sample1.2s (16.5%)

explain140.0ms (2%)

preprocess308.0ms (4.4%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify207.0ms (2.9%)

localize32.0ms (0.4%)

series33.0ms (0.5%)

simplify196.0ms (2.8%)

rewrite72.0ms (1%)

eval9.0ms (0.1%)

prune4.0ms (0.1%)

simplify217.0ms (3.1%)

localize302.0ms (4.3%)

series65.0ms (0.9%)

simplify143.0ms (2%)

rewrite94.0ms (1.3%)

eval62.0ms (0.9%)

prune17.0ms (0.2%)

simplify105.0ms (1.5%)

localize180.0ms (2.6%)

series57.0ms (0.8%)

simplify146.0ms (2.1%)

rewrite93.0ms (1.3%)

eval63.0ms (0.9%)

prune32.0ms (0.5%)

simplify207.0ms (2.9%)

localize379.0ms (5.4%)

series75.0ms (1.1%)

simplify167.0ms (2.4%)

rewrite192.0ms (2.7%)

eval38.0ms (0.5%)

prune32.0ms (0.5%)

regimes66.0ms (0.9%)

regimes64.0ms (0.9%)

regimes64.0ms (0.9%)

regimes24.0ms (0.3%)

regimes53.0ms (0.8%)

regimes23.0ms (0.3%)

regimes14.0ms (0.2%)

regimes49.0ms (0.7%)

regimes29.0ms (0.4%)

regimes22.0ms (0.3%)

regimes30.0ms (0.4%)

regimes12.0ms (0.2%)

regimes14.0ms (0.2%)

regimes10.0ms (0.1%)

regimes27.0ms (0.4%)

regimes3.0ms (0%)

regimes7.0ms (0.1%)

regimes17.0ms (0.2%)

regimes5.0ms (0.1%)

regimes35.0ms (0.5%)

bsearch39.0ms (0.5%)

bsearch20.0ms (0.3%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch2.0ms (0%)

bsearch1.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

simplify67.0ms (0.9%)

derivations1.3s (18.8%)

preprocess193.0ms (2.7%)

end0.0ms (0%)

Profiling