Metrics for math.sin on complex, real part

start0.0ms (0%)

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

analyze0.0ms (0%)

Memory

0.3MiB live, 0.3MiB 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.1s (35.1%)

Memory

42.0MiB live, 1 364.0MiB allocated; 229ms collecting garbage

Samples

834.0ms	8 255×	0	valid
0.0ms	1×	1	valid

Precisions

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

ival-sin: 278.0ms (50.4% of total)

ival-exp: 153.0ms (27.7% of total)

ival-mult!: 83.0ms (15.1% of total)

ival-add!: 19.0ms (3.4% of total)

ival-sub!: 17.0ms (3.1% of total)

adjust: 2.0ms (0.4% of total)

Bogosity

explain118.0ms (3.8%)

Memory

-0.8MiB live, 240.2MiB allocated; 19ms collecting garbage

FPErrors

Click to see full error table

Overpredictions	Example	Example	Subexpression
0	-	-	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`
0	-	-	`(exp.f64 im)`
0	-	-	`(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))`
0	-	-	`(sin.f64 re)`
0	-	-	`#s(literal 0 binary64)`
0	-	-	`im`
0	-	-	`(-.f64 #s(literal 0 binary64) im)`
0	-	-	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
0	-	-	`re`
0	-	-	`#s(literal 1/2 binary64)`
1	(-9.336540591445727e+270 102.75499939414571)	-	`(exp.f64 (-.f64 #s(literal 0 binary64) im))`

Explanations

Click to see full explanations table

Operator	Subexpression	Explanation	Count
`exp.f64`	`(exp.f64 (-.f64 #s(literal 0 binary64) im))`	sensitivity	1	0

Confusion

	Predicted +	Predicted -
+	0	0
-	1	255

Precision

0.0

Recall

0/0

Confusion?

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

Precision?

0.0

Recall?

0/0

Freqs

test

number	freq
0	255
1	1

Total Confusion?

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

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: 30.0ms

ival-sin: 15.0ms (49.3% of total)

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

ival-mult!: 5.0ms (16.4% of total)

ival-sub!: 1.0ms (3.3% of total)

ival-add!: 1.0ms (3.3% of total)

adjust: 0.0ms (0% of total)

preprocess30.0ms (1%)

Memory

-17.2MiB live, 28.9MiB allocated; 6ms collecting garbage

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	30	68
1	114	66
2	468	66
3	1683	66

Stop Event

1×	node-limit

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

Symmetry

(abs im)

(negabs re)

Compiler

Compiled 24 to 22 computations (8.3% saved)

series9.0ms (0.3%)

Memory

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

Counts

11 → 40

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
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (exp (neg im)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole 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)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 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))))))))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* 1/2 re)))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* -1/12 (pow re 2))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))))
#s(approx (sin re) #s(hole binary64 re))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))))
#s(approx re #s(hole binary64 re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* 1/2 (sin re))))
#s(approx (sin re) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (+ (exp (- 0 im)) (exp im)) #s(hole binary64 2))
#s(approx (+ (exp (- 0 im)) (exp im)) #s(hole binary64 (+ 2 (pow im 2))))
#s(approx (+ (exp (- 0 im)) (exp im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))))
#s(approx (+ (exp (- 0 im)) (exp im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))))
#s(approx (exp (- 0 im)) #s(hole binary64 1))
#s(approx (exp (- 0 im)) #s(hole binary64 (+ 1 (* -1 im))))
#s(approx (exp (- 0 im)) #s(hole binary64 (+ 1 (* im (- (* 1/2 im) 1)))))
#s(approx (exp (- 0 im)) #s(hole binary64 (+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))))
#s(approx (- 0 im) #s(hole binary64 (* -1 im)))
#s(approx im #s(hole binary64 im))
#s(approx (exp im) #s(hole binary64 1))
#s(approx (exp im) #s(hole binary64 (+ 1 im)))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* 1/2 im))))))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))))
#s(approx (+ (exp (- 0 im)) (exp im)) #s(hole binary64 (+ (exp im) (exp (neg im)))))
#s(approx (exp (- 0 im)) #s(hole binary64 (exp (neg im))))
#s(approx (exp im) #s(hole binary64 (exp im)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))))
#s(approx (+ (exp (- 0 im)) (exp im)) #s(hole binary64 (+ (exp im) (exp (* -1 im)))))
#s(approx (exp (- 0 im)) #s(hole binary64 (exp (* -1 im))))

Calls

6 calls:

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

rewrite206.0ms (6.7%)

Memory

-4.4MiB live, 285.2MiB allocated; 57ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	182	731
0	193	635
1	1124	612
0	8419	576

Stop Event

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

Counts

51 → 126

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)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (exp (neg im)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole 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)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 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))))))))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* 1/2 re)))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* -1/12 (pow re 2))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))))
#s(approx (sin re) #s(hole binary64 re))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))))
#s(approx re #s(hole binary64 re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* 1/2 (sin re))))
#s(approx (sin re) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (+ (exp (- 0 im)) (exp im)) #s(hole binary64 2))
#s(approx (+ (exp (- 0 im)) (exp im)) #s(hole binary64 (+ 2 (pow im 2))))
#s(approx (+ (exp (- 0 im)) (exp im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))))
#s(approx (+ (exp (- 0 im)) (exp im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))))
#s(approx (exp (- 0 im)) #s(hole binary64 1))
#s(approx (exp (- 0 im)) #s(hole binary64 (+ 1 (* -1 im))))
#s(approx (exp (- 0 im)) #s(hole binary64 (+ 1 (* im (- (* 1/2 im) 1)))))
#s(approx (exp (- 0 im)) #s(hole binary64 (+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))))
#s(approx (- 0 im) #s(hole binary64 (* -1 im)))
#s(approx im #s(hole binary64 im))
#s(approx (exp im) #s(hole binary64 1))
#s(approx (exp im) #s(hole binary64 (+ 1 im)))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* 1/2 im))))))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))))
#s(approx (+ (exp (- 0 im)) (exp im)) #s(hole binary64 (+ (exp im) (exp (neg im)))))
#s(approx (exp (- 0 im)) #s(hole binary64 (exp (neg im))))
#s(approx (exp im) #s(hole binary64 (exp im)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))))
#s(approx (+ (exp (- 0 im)) (exp im)) #s(hole binary64 (+ (exp im) (exp (* -1 im)))))
#s(approx (exp (- 0 im)) #s(hole binary64 (exp (* -1 im))))

Outputs
(.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 #s(literal 1/2 binary64) (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)))
(/.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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))))
(/.f64 (-.f64 (.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im)))) (.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)))) (-.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im))))
(/.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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (-.f64 (.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im))) (.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im))))))
(fma.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64)))
(fma.f64 (.f64 (sin.f64 re) (exp.f64 im)) #s(literal 1/2 binary64) (.f64 (*.f64 (sin.f64 re) (exp.f64 (neg.f64 im))) #s(literal 1/2 binary64)))
(fma.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (exp.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(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 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im)) (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im) (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))))
(fma.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re)) (.f64 #s(literal 1/2 binary64) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))))
(fma.f64 #s(literal 1/2 binary64) (.f64 (sin.f64 re) (exp.f64 im)) (.f64 #s(literal 1/2 binary64) (*.f64 (sin.f64 re) (exp.f64 (neg.f64 im)))))
(-.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 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 #s(literal -1/2 binary64) (sin.f64 re)) (exp.f64 im)))
(+.f64 (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)) (.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64)))
(+.f64 (.f64 (.f64 (sin.f64 re) (exp.f64 im)) #s(literal 1/2 binary64)) (.f64 (.f64 (sin.f64 re) (exp.f64 (neg.f64 im))) #s(literal 1/2 binary64)))
(+.f64 (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re))) (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))))
(+.f64 (.f64 #s(literal 1/2 binary64) (.f64 (sin.f64 re) (exp.f64 im))) (.f64 #s(literal 1/2 binary64) (.f64 (sin.f64 re) (exp.f64 (neg.f64 im)))))
(+.f64 (.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))))
(+.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))))
(+.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)))
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
#s(literal 1/2 binary64)
(sin.f64 re)
re
(*.f64 #s(literal 2 binary64) (cosh.f64 im))
(/.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) (sinh.f64 im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (exp.f64 (neg.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 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (exp.f64 im) (exp.f64 im) (expm1.f64 (*.f64 (neg.f64 im) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 2 binary64)) (expm1.f64 (*.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) (sinh.f64 im)))
(/.f64 (-.f64 (pow.f64 (exp.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 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 3 binary64))) (fma.f64 (exp.f64 im) (exp.f64 im) (expm1.f64 (*.f64 (neg.f64 im) #s(literal 2 binary64)))))
(/.f64 (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 2 binary64)) (expm1.f64 (*.f64 im #s(literal 2 binary64)))))
(fma.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 im #s(literal 2 binary64))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 im #s(literal 2 binary64))) (exp.f64 im))
(-.f64 (+.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 im))
(-.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (.f64 #s(literal 2 binary64) (sinh.f64 im))) (/.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 2 binary64)) (.f64 #s(literal 2 binary64) (sinh.f64 im))))
(-.f64 (/.f64 (pow.f64 (exp.f64 (neg.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 (exp.f64 (neg.f64 im)) (cosh.f64 im)) (sinh.f64 im))
(+.f64 (+.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 (neg.f64 im)))
(+.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (fma.f64 (exp.f64 im) (exp.f64 im) (expm1.f64 (.f64 (neg.f64 im) #s(literal 2 binary64))))) (/.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 3 binary64)) (fma.f64 (exp.f64 im) (exp.f64 im) (expm1.f64 (.f64 (neg.f64 im) #s(literal 2 binary64))))))
(+.f64 (/.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 3 binary64)) (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 2 binary64)) (expm1.f64 (.f64 im #s(literal 2 binary64))))) (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (+.f64 (pow.f64 (exp.f64 (neg.f64 im)) #s(literal 2 binary64)) (expm1.f64 (.f64 im #s(literal 2 binary64))))))
(+.f64 (cosh.f64 im) (+.f64 (sinh.f64 (neg.f64 im)) (exp.f64 im)))
(+.f64 (cosh.f64 im) (+.f64 (sinh.f64 im) (exp.f64 (neg.f64 im))))
(+.f64 (cosh.f64 im) (cosh.f64 im))
(+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))
(+.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 im #s(literal 2 binary64))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 im #s(literal 2 binary64))))
(pow.f64 (exp.f64 #s(literal -1 binary64)) im)
(pow.f64 (exp.f64 im) #s(literal -1 binary64))
(/.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 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))
(neg.f64 (/.f64 #s(literal -1 binary64) (exp.f64 im)))
(-.f64 (cosh.f64 im) (sinh.f64 im))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) im))
(exp.f64 (neg.f64 im))
(+.f64 (cosh.f64 im) (sinh.f64 (neg.f64 im)))
(*.f64 #s(literal -1 binary64) im)
(*.f64 #s(literal 1 binary64) (neg.f64 im))
(*.f64 im #s(literal -1 binary64))
(/.f64 (neg.f64 (pow.f64 (neg.f64 im) #s(literal 3 binary64))) (neg.f64 (fma.f64 im im #s(literal 0 binary64))))
(/.f64 (.f64 #s(literal 2 binary64) (.f64 (neg.f64 im) im)) (*.f64 #s(literal 2 binary64) im))
(/.f64 (.f64 #s(literal 2 binary64) (pow.f64 (neg.f64 im) #s(literal 3 binary64))) (.f64 #s(literal 2 binary64) (fma.f64 im im #s(literal 0 binary64))))
(/.f64 (*.f64 (neg.f64 im) im) im)
(/.f64 (pow.f64 (neg.f64 im) #s(literal 3 binary64)) (fma.f64 im im #s(literal 0 binary64)))
(/.f64 (*.f64 im im) (neg.f64 im))
(neg.f64 (*.f64 #s(literal -1 binary64) (neg.f64 im)))
(neg.f64 im)
(-.f64 (/.f64 #s(literal 0 binary64) im) (/.f64 (*.f64 im im) im))
(-.f64 (/.f64 #s(literal 0 binary64) (fma.f64 im im #s(literal 0 binary64))) (/.f64 (pow.f64 im #s(literal 3 binary64)) (fma.f64 im im #s(literal 0 binary64))))
(-.f64 #s(literal 0 binary64) im)
#s(literal 0 binary64)
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) (exp.f64 (neg.f64 im)))
(exp.f64 im)
(+.f64 (cosh.f64 im) (sinh.f64 im))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (fma.f64 (.f64 re re) #s(literal -1/12 binary64) #s(literal 1/2 binary64))) re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (fma.f64 #s(literal 1/240 binary64) (.f64 re re) #s(literal -1/12 binary64))) (.f64 re re) (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64))) re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 (fma.f64 (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (fma.f64 #s(literal -1/10080 binary64) (.f64 re re) #s(literal 1/240 binary64))) (.f64 re re) (.f64 #s(literal -1/12 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im)))) (.f64 re re) (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64))) re))
#s(approx (* 1/2 (sin re)) (*.f64 re #s(literal 1/2 binary64)))
#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 (* 1/2 (sin re)) (.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))
#s(approx (* 1/2 (sin re)) (.f64 (fma.f64 (-.f64 (.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))
#s(approx (sin re) re)
#s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re))
#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 (sin re) (.f64 (fma.f64 (-.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)) (*.f64 re re) #s(literal 1 binary64)) re))
#s(approx re re)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64)))
#s(approx (* 1/2 (sin re)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
#s(approx (sin re) (sin.f64 re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin.f64 re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 im im) #s(literal 1 binary64)) (sin.f64 re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (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)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (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)))
#s(approx (+ (exp (- 0 im)) (exp im)) #s(literal 2 binary64))
#s(approx (+ (exp (- 0 im)) (exp im)) (fma.f64 im im #s(literal 2 binary64)))
#s(approx (+ (exp (- 0 im)) (exp im)) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/12 binary64) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64)))
#s(approx (+ (exp (- 0 im)) (exp 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)) #s(literal 1 binary64))
#s(approx (exp (- 0 im)) (-.f64 #s(literal 1 binary64) im))
#s(approx (exp (- 0 im)) (fma.f64 (fma.f64 im #s(literal 1/2 binary64) #s(literal -1 binary64)) im #s(literal 1 binary64)))
#s(approx (exp (- 0 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)))
#s(approx (- 0 im) (neg.f64 im))
#s(approx im im)
#s(approx (exp im) #s(literal 1 binary64))
#s(approx (exp im) (-.f64 im #s(literal -1 binary64)))
#s(approx (exp im) (fma.f64 (fma.f64 im #s(literal 1/2 binary64) #s(literal 1 binary64)) im #s(literal 1 binary64)))
#s(approx (exp 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)))
#s(approx (+ (exp (- 0 im)) (exp im)) (*.f64 #s(literal 2 binary64) (cosh.f64 im)))
#s(approx (exp (- 0 im)) (exp.f64 (neg.f64 im)))
#s(approx (exp im) (exp.f64 im))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64)))
#s(approx (+ (exp (- 0 im)) (exp im)) (*.f64 #s(literal 2 binary64) (cosh.f64 im)))
#s(approx (exp (- 0 im)) (exp.f64 (neg.f64 im)))

eval14.0ms (0.5%)

Memory: -10.5MiB live, 35.7MiB allocated; 3ms collecting garbage
Compiler: Compiled 2 343 to 477 computations (79.6% saved)

prune5.0ms (0.2%)

Memory

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

Pruning

6 alts after pruning (6 fresh and 0 done)

	Pruned	Kept	Total
New	110	6	116
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	111	6	117

Accuracy

100.0%

Counts

117 → 6

Alt Table

Click to see full alt table

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

Compiler

Compiled 170 to 142 computations (16.5% saved)

series32.0ms (1%)

Memory

-25.0MiB live, 67.7MiB allocated; 6ms collecting garbage

Counts

24 → 112

Calls

Call 1

Inputs
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im) (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))))
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
(sin.f64 re)
re
#s(literal 1/2 binary64)
(exp.f64 im)
im
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im)))
(exp.f64 (neg.f64 im))
(neg.f64 im)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin.f64 re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
(.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im)))
(*.f64 re #s(literal 1/2 binary64))
(*.f64 #s(literal 2 binary64) (cosh.f64 im))
#s(literal 2 binary64)
(cosh.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 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -1 binary64)) (exp.f64 im)))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
(+.f64 (pow.f64 (exp.f64 im) #s(literal -1 binary64)) (exp.f64 im))
(pow.f64 (exp.f64 im) #s(literal -1 binary64))
#s(literal -1 binary64)

Outputs
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (* re (+ (* 1/2 (exp im)) (* 1/2 (exp (neg im)))))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (* re (+ (* 1/2 (exp im)) (+ (* 1/2 (exp (neg im))) (* (pow re 2) (+ (* -1/12 (exp im)) (* -1/12 (exp (neg im))))))))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (* re (+ (* 1/2 (exp im)) (+ (* 1/2 (exp (neg im))) (* (pow re 2) (+ (* -1/12 (exp im)) (+ (* -1/12 (exp (neg im))) (* (pow re 2) (+ (* 1/240 (exp im)) (* 1/240 (exp (neg im)))))))))))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (* re (+ (* 1/2 (exp im)) (+ (* 1/2 (exp (neg im))) (* (pow re 2) (+ (* -1/12 (exp im)) (+ (* -1/12 (exp (neg im))) (* (pow re 2) (+ (* 1/240 (exp im)) (+ (* 1/240 (exp (neg im))) (* (pow re 2) (+ (* -1/10080 (exp im)) (* -1/10080 (exp (neg im))))))))))))))))
#s(approx (* (sin re) 1/2) #s(hole binary64 (* 1/2 re)))
#s(approx (* (sin re) 1/2) #s(hole binary64 (* re (+ 1/2 (* -1/12 (pow re 2))))))
#s(approx (* (sin re) 1/2) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))))
#s(approx (* (sin re) 1/2) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))))
#s(approx (sin re) #s(hole binary64 re))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))))
#s(approx re #s(hole binary64 re))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* 1/2 (* re (exp (neg im))))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (exp (neg im)))) (* 1/2 (exp (neg im)))))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* re (+ (* 1/2 (exp (neg im))) (* (pow re 2) (+ (* -1/12 (exp (neg im))) (* 1/240 (* (pow re 2) (exp (neg im))))))))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* re (+ (* 1/2 (exp (neg im))) (* (pow re 2) (+ (* -1/12 (exp (neg im))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (exp (neg im)))) (* 1/240 (exp (neg im)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (exp (neg im)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole 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)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 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))))))))))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* re 1/2) #s(hole binary64 (* 1/2 re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (* 1/2 (* re (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/2 (+ (exp im) (/ 1 (exp im))))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (* 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)))))))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (* 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))))))))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (* re (+ (exp im) (/ 1 (exp im))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (* re (+ (exp im) (+ (* -1/6 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (/ 1 (exp im)))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (* 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)))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (* 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)))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/2 (+ (exp im) (/ 1 (exp im))))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 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)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 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))))))))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* 1/2 re)))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* -1/12 (pow re 2))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (+ (* 1/2 (* (exp im) (sin re))) (* 1/2 (* (exp (neg im)) (sin re))))))
#s(approx (* (sin re) 1/2) #s(hole binary64 (* 1/2 (sin re))))
#s(approx (sin re) #s(hole binary64 (sin re)))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* 1/2 (* (exp (neg im)) (sin re)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (* (sin re) (+ (exp im) (/ 1 (exp im))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* 1/2 (sin re))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (sin re)))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (+ (sin re) (* im (+ (* -1/2 (sin re)) (* 1/2 (sin re)))))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (+ (sin re) (* im (+ (* -1/2 (sin re)) (+ (* 1/2 (sin re)) (* 1/2 (* im (sin re)))))))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (+ (sin re) (* im (+ (* -1/2 (sin re)) (+ (* 1/2 (sin re)) (* im (+ (* 1/2 (sin re)) (* im (+ (* -1/12 (sin re)) (* 1/12 (sin re))))))))))))
#s(approx (exp im) #s(hole binary64 1))
#s(approx (exp im) #s(hole binary64 (+ 1 im)))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* 1/2 im))))))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))))
#s(approx im #s(hole binary64 im))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* 1/2 (sin re))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (+ (* -1/2 (* im (sin re))) (* 1/2 (sin re)))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (+ (* 1/2 (sin re)) (* im (+ (* -1/2 (sin re)) (* 1/4 (* im (sin re))))))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (+ (* 1/2 (sin re)) (* im (+ (* -1/2 (sin re)) (* im (+ (* -1/12 (* im (sin re))) (* 1/4 (sin re)))))))))
#s(approx (exp (neg im)) #s(hole binary64 1))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* -1 im))))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* im (- (* 1/2 im) 1)))))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 re))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (+ re (* 1/2 (* (pow im 2) re)))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* 1/24 (* (pow im 2) re)) (* 1/2 re))))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* 1/2 re) (* (pow im 2) (+ (* 1/720 (* (pow im 2) re)) (* 1/24 re))))))))
#s(approx (* 2 (cosh im)) #s(hole binary64 2))
#s(approx (* 2 (cosh im)) #s(hole binary64 (+ 2 (pow im 2))))
#s(approx (* 2 (cosh im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))))
#s(approx (* 2 (cosh im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))))
#s(approx (cosh im) #s(hole binary64 1))
#s(approx (cosh im) #s(hole binary64 (+ 1 (* 1/2 (pow im 2)))))
#s(approx (cosh im) #s(hole binary64 (+ 1 (* (pow im 2) (+ 1/2 (* 1/24 (pow im 2)))))))
#s(approx (cosh im) #s(hole binary64 (+ 1 (* (pow im 2) (+ 1/2 (* (pow im 2) (+ 1/24 (* 1/720 (pow im 2)))))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (sin re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (* 2 (sin re))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (+ (* 2 (sin re)) (* (pow im 2) (sin re)))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (+ (* 2 (sin re)) (* (pow im 2) (+ (sin re) (* 1/12 (* (pow im 2) (sin re))))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (+ (* 2 (sin re)) (* (pow im 2) (+ (sin re) (* (pow im 2) (+ (* 1/360 (* (pow im 2) (sin re))) (* 1/12 (sin re)))))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 2))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ 2 (pow im 2))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))))
#s(approx (pow (exp im) -1) #s(hole binary64 1))
#s(approx (pow (exp im) -1) #s(hole binary64 (+ 1 (* -1 im))))
#s(approx (pow (exp im) -1) #s(hole binary64 (+ 1 (* im (- (* 1/2 im) 1)))))
#s(approx (pow (exp im) -1) #s(hole binary64 (+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))))
#s(approx (exp im) #s(hole binary64 (exp im)))
#s(approx (exp (neg im)) #s(hole binary64 (exp (neg im))))
#s(approx (* 2 (cosh im)) #s(hole binary64 (+ (exp im) (/ 1 (exp im)))))
#s(approx (cosh im) #s(hole binary64 (* 1/2 (+ (exp im) (/ 1 (exp im))))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ (exp im) (/ 1 (exp im)))))
#s(approx (pow (exp im) -1) #s(hole binary64 (/ 1 (exp im))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (+ (* 1/2 (* (exp im) (sin re))) (* 1/2 (* (exp (* -1 im)) (sin re))))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* 1/2 (* (exp (* -1 im)) (sin re)))))
#s(approx (exp (neg im)) #s(hole binary64 (exp (* -1 im))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))))

Calls

6 calls:

Time	Variable		Point	Expression
7.0ms	re	@	0	((+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) (* (sin re) 1/2) (sin re) re 1/2 (exp im) im (* (* (sin re) 1/2) (exp (neg im))) (exp (neg im)) (neg im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* re 1/2) (* 2 (cosh im))) (* re 1/2) (* 2 (cosh im)) 2 (cosh im) (* (* (* 2 (cosh im)) (sin re)) 1/2) (* (* 2 (cosh im)) (sin re)) (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im)) (pow (exp im) -1) -1)
6.0ms	im	@	inf	((+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) (* (sin re) 1/2) (sin re) re 1/2 (exp im) im (* (* (sin re) 1/2) (exp (neg im))) (exp (neg im)) (neg im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* re 1/2) (* 2 (cosh im))) (* re 1/2) (* 2 (cosh im)) 2 (cosh im) (* (* (* 2 (cosh im)) (sin re)) 1/2) (* (* 2 (cosh im)) (sin re)) (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im)) (pow (exp im) -1) -1)
5.0ms	im	@	0	((+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) (* (sin re) 1/2) (sin re) re 1/2 (exp im) im (* (* (sin re) 1/2) (exp (neg im))) (exp (neg im)) (neg im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* re 1/2) (* 2 (cosh im))) (* re 1/2) (* 2 (cosh im)) 2 (cosh im) (* (* (* 2 (cosh im)) (sin re)) 1/2) (* (* 2 (cosh im)) (sin re)) (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im)) (pow (exp im) -1) -1)
4.0ms	im	@	-inf	((+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) (* (sin re) 1/2) (sin re) re 1/2 (exp im) im (* (* (sin re) 1/2) (exp (neg im))) (exp (neg im)) (neg im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* re 1/2) (* 2 (cosh im))) (* re 1/2) (* 2 (cosh im)) 2 (cosh im) (* (* (* 2 (cosh im)) (sin re)) 1/2) (* (* 2 (cosh im)) (sin re)) (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im)) (pow (exp im) -1) -1)
4.0ms	re	@	-inf	((+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) (* (sin re) 1/2) (sin re) re 1/2 (exp im) im (* (* (sin re) 1/2) (exp (neg im))) (exp (neg im)) (neg im) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* re 1/2) (* 2 (cosh im))) (* re 1/2) (* 2 (cosh im)) 2 (cosh im) (* (* (* 2 (cosh im)) (sin re)) 1/2) (* (* 2 (cosh im)) (sin re)) (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im)) (pow (exp im) -1) -1)

rewrite252.0ms (8.2%)

Memory

29.2MiB live, 265.5MiB allocated; 42ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	457	2723
0	493	2353
1	2932	2353
0	10231	2234

Stop Event

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

Counts

136 → 373

Calls

Call 1

Inputs
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im) (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))))
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
(sin.f64 re)
re
#s(literal 1/2 binary64)
(exp.f64 im)
im
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im)))
(exp.f64 (neg.f64 im))
(neg.f64 im)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin.f64 re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
(.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im)))
(*.f64 re #s(literal 1/2 binary64))
(*.f64 #s(literal 2 binary64) (cosh.f64 im))
#s(literal 2 binary64)
(cosh.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 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -1 binary64)) (exp.f64 im)))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
(+.f64 (pow.f64 (exp.f64 im) #s(literal -1 binary64)) (exp.f64 im))
(pow.f64 (exp.f64 im) #s(literal -1 binary64))
#s(literal -1 binary64)
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (* re (+ (* 1/2 (exp im)) (* 1/2 (exp (neg im)))))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (* re (+ (* 1/2 (exp im)) (+ (* 1/2 (exp (neg im))) (* (pow re 2) (+ (* -1/12 (exp im)) (* -1/12 (exp (neg im))))))))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (* re (+ (* 1/2 (exp im)) (+ (* 1/2 (exp (neg im))) (* (pow re 2) (+ (* -1/12 (exp im)) (+ (* -1/12 (exp (neg im))) (* (pow re 2) (+ (* 1/240 (exp im)) (* 1/240 (exp (neg im)))))))))))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (* re (+ (* 1/2 (exp im)) (+ (* 1/2 (exp (neg im))) (* (pow re 2) (+ (* -1/12 (exp im)) (+ (* -1/12 (exp (neg im))) (* (pow re 2) (+ (* 1/240 (exp im)) (+ (* 1/240 (exp (neg im))) (* (pow re 2) (+ (* -1/10080 (exp im)) (* -1/10080 (exp (neg im))))))))))))))))
#s(approx (* (sin re) 1/2) #s(hole binary64 (* 1/2 re)))
#s(approx (* (sin re) 1/2) #s(hole binary64 (* re (+ 1/2 (* -1/12 (pow re 2))))))
#s(approx (* (sin re) 1/2) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))))
#s(approx (* (sin re) 1/2) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))))
#s(approx (sin re) #s(hole binary64 re))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))))
#s(approx re #s(hole binary64 re))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* 1/2 (* re (exp (neg im))))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (exp (neg im)))) (* 1/2 (exp (neg im)))))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* re (+ (* 1/2 (exp (neg im))) (* (pow re 2) (+ (* -1/12 (exp (neg im))) (* 1/240 (* (pow re 2) (exp (neg im))))))))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* re (+ (* 1/2 (exp (neg im))) (* (pow re 2) (+ (* -1/12 (exp (neg im))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (exp (neg im)))) (* 1/240 (exp (neg im)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (exp (neg im)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole 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)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 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))))))))))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* re 1/2) #s(hole binary64 (* 1/2 re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (* 1/2 (* re (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/2 (+ (exp im) (/ 1 (exp im))))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (* 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)))))))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (* 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))))))))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (* re (+ (exp im) (/ 1 (exp im))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (* re (+ (exp im) (+ (* -1/6 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (/ 1 (exp im)))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (* 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)))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (* 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)))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/2 (+ (exp im) (/ 1 (exp im))))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 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)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 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))))))))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* 1/2 re)))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* -1/12 (pow re 2))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (+ (* 1/2 (* (exp im) (sin re))) (* 1/2 (* (exp (neg im)) (sin re))))))
#s(approx (* (sin re) 1/2) #s(hole binary64 (* 1/2 (sin re))))
#s(approx (sin re) #s(hole binary64 (sin re)))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* 1/2 (* (exp (neg im)) (sin re)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (* (sin re) (+ (exp im) (/ 1 (exp im))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* 1/2 (sin re))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (sin re)))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (+ (sin re) (* im (+ (* -1/2 (sin re)) (* 1/2 (sin re)))))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (+ (sin re) (* im (+ (* -1/2 (sin re)) (+ (* 1/2 (sin re)) (* 1/2 (* im (sin re)))))))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (+ (sin re) (* im (+ (* -1/2 (sin re)) (+ (* 1/2 (sin re)) (* im (+ (* 1/2 (sin re)) (* im (+ (* -1/12 (sin re)) (* 1/12 (sin re))))))))))))
#s(approx (exp im) #s(hole binary64 1))
#s(approx (exp im) #s(hole binary64 (+ 1 im)))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* 1/2 im))))))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))))
#s(approx im #s(hole binary64 im))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* 1/2 (sin re))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (+ (* -1/2 (* im (sin re))) (* 1/2 (sin re)))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (+ (* 1/2 (sin re)) (* im (+ (* -1/2 (sin re)) (* 1/4 (* im (sin re))))))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (+ (* 1/2 (sin re)) (* im (+ (* -1/2 (sin re)) (* im (+ (* -1/12 (* im (sin re))) (* 1/4 (sin re)))))))))
#s(approx (exp (neg im)) #s(hole binary64 1))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* -1 im))))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* im (- (* 1/2 im) 1)))))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 re))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (+ re (* 1/2 (* (pow im 2) re)))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* 1/24 (* (pow im 2) re)) (* 1/2 re))))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* 1/2 re) (* (pow im 2) (+ (* 1/720 (* (pow im 2) re)) (* 1/24 re))))))))
#s(approx (* 2 (cosh im)) #s(hole binary64 2))
#s(approx (* 2 (cosh im)) #s(hole binary64 (+ 2 (pow im 2))))
#s(approx (* 2 (cosh im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))))
#s(approx (* 2 (cosh im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))))
#s(approx (cosh im) #s(hole binary64 1))
#s(approx (cosh im) #s(hole binary64 (+ 1 (* 1/2 (pow im 2)))))
#s(approx (cosh im) #s(hole binary64 (+ 1 (* (pow im 2) (+ 1/2 (* 1/24 (pow im 2)))))))
#s(approx (cosh im) #s(hole binary64 (+ 1 (* (pow im 2) (+ 1/2 (* (pow im 2) (+ 1/24 (* 1/720 (pow im 2)))))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (sin re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (* 2 (sin re))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (+ (* 2 (sin re)) (* (pow im 2) (sin re)))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (+ (* 2 (sin re)) (* (pow im 2) (+ (sin re) (* 1/12 (* (pow im 2) (sin re))))))))
#s(approx (* (* 2 (cosh im)) (sin re)) #s(hole binary64 (+ (* 2 (sin re)) (* (pow im 2) (+ (sin re) (* (pow im 2) (+ (* 1/360 (* (pow im 2) (sin re))) (* 1/12 (sin re)))))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 2))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ 2 (pow im 2))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))))
#s(approx (pow (exp im) -1) #s(hole binary64 1))
#s(approx (pow (exp im) -1) #s(hole binary64 (+ 1 (* -1 im))))
#s(approx (pow (exp im) -1) #s(hole binary64 (+ 1 (* im (- (* 1/2 im) 1)))))
#s(approx (pow (exp im) -1) #s(hole binary64 (+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))))
#s(approx (exp im) #s(hole binary64 (exp im)))
#s(approx (exp (neg im)) #s(hole binary64 (exp (neg im))))
#s(approx (* 2 (cosh im)) #s(hole binary64 (+ (exp im) (/ 1 (exp im)))))
#s(approx (cosh im) #s(hole binary64 (* 1/2 (+ (exp im) (/ 1 (exp im))))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ (exp im) (/ 1 (exp im)))))
#s(approx (pow (exp im) -1) #s(hole binary64 (/ 1 (exp im))))
#s(approx (+ (* (* (sin re) 1/2) (exp im)) (* (* (sin re) 1/2) (exp (neg im)))) #s(hole binary64 (+ (* 1/2 (* (exp im) (sin re))) (* 1/2 (* (exp (* -1 im)) (sin re))))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) #s(hole binary64 (* 1/2 (* (exp (* -1 im)) (sin re)))))
#s(approx (exp (neg im)) #s(hole binary64 (exp (* -1 im))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))))

Outputs
(.f64 (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) (sin.f64 re)) #s(literal 1/2 binary64))
(.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) (sin.f64 re)))
(/.f64 (fma.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.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))))))
(/.f64 (fma.f64 (pow.f64 (sin.f64 re) #s(literal 3 binary64)) (.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) #s(literal 1/8 binary64)) (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.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))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.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))))))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))))
(/.f64 (-.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (.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)))))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64))) (-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re))))
(/.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.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)))))))
(/.f64 (fma.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re))))))
(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 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (*.f64 (exp.f64 (neg.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 (*.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (exp.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(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 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im)) (.f64 (exp.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(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 (sin.f64 re) (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (.f64 (exp.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (sin.f64 re) (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (*.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))
(-.f64 (/.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (.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))))) (/.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (.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))))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))) (/.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))
(-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 #s(literal -1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))))
(-.f64 (.f64 (exp.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 (neg.f64 im))))
(+.f64 (/.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.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))))))) (/.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.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))))))))
(+.f64 (/.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))) (/.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))))
(+.f64 (.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)))
(+.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.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))))
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
(sin.f64 re)
re
#s(literal 1/2 binary64)
(/.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 (cosh.f64 im) (sinh.f64 im))
im
(.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im)))
(.f64 (sin.f64 re) (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)))
(*.f64 (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))))
(*.f64 (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))))
(*.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)))
(pow.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) #s(literal -1/2 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) im)
(pow.f64 (exp.f64 im) #s(literal -1 binary64))
(/.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 (neg.f64 (exp.f64 im))))
(/.f64 #s(literal 1 binary64) (pow.f64 (exp.f64 im) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (exp.f64 im))
(/.f64 #s(literal -1 binary64) (neg.f64 (exp.f64 im)))
(-.f64 (cosh.f64 im) (sinh.f64 im))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) im))
(exp.f64 (neg.f64 im))
(+.f64 (cosh.f64 im) (sinh.f64 (neg.f64 im)))
(*.f64 #s(literal -1 binary64) im)
(*.f64 im #s(literal -1 binary64))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) (neg.f64 (+.f64 #s(literal 0 binary64) im)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 0 binary64) (fma.f64 im im (*.f64 #s(literal 0 binary64) im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (+.f64 #s(literal 0 binary64) im))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 im im (*.f64 #s(literal 0 binary64) im))))
(neg.f64 im)
(-.f64 (/.f64 #s(literal 0 binary64) (+.f64 #s(literal 0 binary64) im)) (/.f64 (*.f64 im im) (+.f64 #s(literal 0 binary64) im)))
(-.f64 (/.f64 #s(literal 0 binary64) (+.f64 #s(literal 0 binary64) (fma.f64 im im (.f64 #s(literal 0 binary64) im)))) (/.f64 (pow.f64 im #s(literal 3 binary64)) (+.f64 #s(literal 0 binary64) (fma.f64 im im (.f64 #s(literal 0 binary64) im)))))
(-.f64 #s(literal 0 binary64) im)
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (sin.f64 re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (.f64 (*.f64 #s(literal 1/2 binary64) re) #s(literal 2 binary64)) (cosh.f64 im)))
(.f64 (.f64 (*.f64 #s(literal 1/2 binary64) re) #s(literal 2 binary64)) (cosh.f64 im))
(.f64 (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) re) #s(literal 1/2 binary64))
(.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) re))
(.f64 (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) re)
(.f64 (.f64 #s(literal 1/2 binary64) re) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) re))
(.f64 re (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
(/.f64 (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) re) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) re) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) re) (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) re) (-.f64 (.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) re) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) re)) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) re) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) re)))))
(/.f64 (+.f64 (pow.f64 (.f64 re (.f64 (exp.f64 im) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 re (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64))) #s(literal 3 binary64))) (fma.f64 (.f64 re (.f64 (exp.f64 im) #s(literal 1/2 binary64))) (.f64 re (.f64 (exp.f64 im) #s(literal 1/2 binary64))) (-.f64 (.f64 (.f64 re (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64))) (.f64 re (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)))) (.f64 (.f64 re (.f64 (exp.f64 im) #s(literal 1/2 binary64))) (.f64 re (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)))))))
(fma.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) re (.f64 (*.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) re))
(fma.f64 re (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (.f64 re (*.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64))))
(+.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) re) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) re))
(+.f64 (.f64 re (.f64 (exp.f64 im) #s(literal 1/2 binary64))) (.f64 re (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64))))
(*.f64 #s(literal 1/2 binary64) re)
(*.f64 re #s(literal 1/2 binary64))
(*.f64 (cosh.f64 im) #s(literal 2 binary64))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 (/.f64 (fma.f64 #s(literal -1 binary64) im (neg.f64 im)) #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 (fma.f64 #s(literal -1 binary64) 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))) (cosh.f64 (/.f64 (-.f64 im im) #s(literal 2 binary64)))))
(*.f64 #s(literal 2 binary64) (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 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (cosh.f64 im) (cosh.f64 im)))))
(/.f64 (fma.f64 (cosh.f64 im) #s(literal 2 binary64) (*.f64 (cosh.f64 im) #s(literal 2 binary64))) #s(literal 2 binary64))
(/.f64 (neg.f64 (-.f64 (pow.f64 (exp.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 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (pow.f64 (exp.f64 im) #s(literal -2 binary64)))) (neg.f64 (*.f64 #s(literal 2 binary64) (sinh.f64 im))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (*.f64 im #s(literal 2 binary64))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64)))) (neg.f64 (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im)))))))
(/.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 2 binary64) (.f64 #s(literal 2 binary64) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))) #s(literal 4 binary64))
(/.f64 (-.f64 (pow.f64 (exp.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 2 binary64)) (pow.f64 (exp.f64 im) #s(literal -2 binary64))) (*.f64 #s(literal 2 binary64) (sinh.f64 im)))
(/.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (*.f64 im #s(literal 2 binary64)))))
(/.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im))))))
(fma.f64 (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 (neg.f64 (neg.f64 im))))
(fma.f64 (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 im))
(fma.f64 (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 (neg.f64 (neg.f64 im))))
(fma.f64 (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 im))
(fma.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (exp.f64 (neg.f64 (neg.f64 im))))
(fma.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (exp.f64 im))
(-.f64 (/.f64 (pow.f64 (exp.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 (exp.f64 im) #s(literal 2 binary64)) (.f64 #s(literal 2 binary64) (sinh.f64 im))) (/.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (.f64 #s(literal 2 binary64) (sinh.f64 im))))
(+.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (.f64 im #s(literal 2 binary64))))) (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (.f64 im #s(literal 2 binary64))))))
(+.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im)))))) (/.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im)))))))
(+.f64 (cosh.f64 im) (cosh.f64 im))
(+.f64 (exp.f64 (neg.f64 im)) (exp.f64 (neg.f64 (neg.f64 im))))
(+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))
(+.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
#s(literal 2 binary64)
(/.f64 (neg.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64))) #s(literal -2 binary64))
(/.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) #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 (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) (sin.f64 re)) #s(literal 1/2 binary64))
(.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) (sin.f64 re)))
(/.f64 (fma.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.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))))))
(/.f64 (fma.f64 (pow.f64 (sin.f64 re) #s(literal 3 binary64)) (.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) #s(literal 1/8 binary64)) (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.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))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.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))))))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))))
(/.f64 (-.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (.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)))))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64))) (-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re))))
(/.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.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)))))))
(/.f64 (fma.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re))))))
(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 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (*.f64 (exp.f64 (neg.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 (*.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (exp.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(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 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im)) (.f64 (exp.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(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 (sin.f64 re) (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (.f64 (exp.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (sin.f64 re) (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (*.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))
(-.f64 (/.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (.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))))) (/.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (.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))))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))) (/.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))
(-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 #s(literal -1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))))
(-.f64 (.f64 (exp.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 (neg.f64 im))))
(+.f64 (/.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.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))))))) (/.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.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))))))))
(+.f64 (/.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))) (/.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))))
(+.f64 (.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)))
(+.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.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))))
(.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (sin.f64 re))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 im) (sin.f64 re)))
(.f64 (sin.f64 re) (.f64 (cosh.f64 im) #s(literal 2 binary64)))
(/.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 3 binary64))) (fma.f64 (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (exp.f64 im) (sin.f64 re)) (-.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))) (.f64 (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))))))
(fma.f64 (exp.f64 im) (sin.f64 re) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))
(fma.f64 (sin.f64 re) (exp.f64 im) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))
(+.f64 (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))
(.f64 (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) (sin.f64 re)) #s(literal 1/2 binary64))
(.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) (sin.f64 re)))
(/.f64 (fma.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.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))))))
(/.f64 (fma.f64 (pow.f64 (sin.f64 re) #s(literal 3 binary64)) (.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) #s(literal 1/8 binary64)) (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.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))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.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))))))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))))
(/.f64 (-.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (.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)))))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64))) (-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re))))
(/.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.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)))))))
(/.f64 (fma.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64)) #s(literal 1/8 binary64) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re))))))
(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 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (*.f64 (exp.f64 (neg.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 (*.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (.f64 (exp.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(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 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im)) (.f64 (exp.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(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 (sin.f64 re) (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (.f64 (exp.f64 im) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 (sin.f64 re) (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (.f64 (exp.f64 (neg.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) (.f64 (*.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)))
(fma.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (*.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))
(-.f64 (/.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (.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))))) (/.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (.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))))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))) (/.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))
(-.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 #s(literal -1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))))
(-.f64 (.f64 (exp.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 (neg.f64 im))))
(+.f64 (/.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.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))))))) (/.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.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))))))))
(+.f64 (/.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))) (/.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))))))
(+.f64 (.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)))
(+.f64 (.f64 (.f64 (exp.f64 im) #s(literal 1/2 binary64)) (sin.f64 re)) (.f64 (.f64 (exp.f64 (neg.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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.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))))
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
(*.f64 (cosh.f64 im) #s(literal 2 binary64))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 (/.f64 (fma.f64 #s(literal -1 binary64) im (neg.f64 im)) #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 (fma.f64 #s(literal -1 binary64) 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))) (cosh.f64 (/.f64 (-.f64 im im) #s(literal 2 binary64)))))
(*.f64 #s(literal 2 binary64) (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 (.f64 (cosh.f64 im) (cosh.f64 im)) (.f64 (cosh.f64 im) (cosh.f64 im)))))
(/.f64 (fma.f64 (cosh.f64 im) #s(literal 2 binary64) (*.f64 (cosh.f64 im) #s(literal 2 binary64))) #s(literal 2 binary64))
(/.f64 (neg.f64 (-.f64 (pow.f64 (exp.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 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (pow.f64 (exp.f64 im) #s(literal -2 binary64)))) (neg.f64 (*.f64 #s(literal 2 binary64) (sinh.f64 im))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (*.f64 im #s(literal 2 binary64))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64)))) (neg.f64 (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im)))))))
(/.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 2 binary64) (.f64 #s(literal 2 binary64) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))) #s(literal 4 binary64))
(/.f64 (-.f64 (pow.f64 (exp.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 2 binary64)) (pow.f64 (exp.f64 im) #s(literal -2 binary64))) (*.f64 #s(literal 2 binary64) (sinh.f64 im)))
(/.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (*.f64 im #s(literal 2 binary64)))))
(/.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im))))))
(fma.f64 (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 (neg.f64 (neg.f64 im))))
(fma.f64 (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 im))
(fma.f64 (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 (neg.f64 (neg.f64 im))))
(fma.f64 (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 im))
(fma.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (exp.f64 (neg.f64 (neg.f64 im))))
(fma.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (exp.f64 im))
(-.f64 (/.f64 (pow.f64 (exp.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 (exp.f64 im) #s(literal 2 binary64)) (.f64 #s(literal 2 binary64) (sinh.f64 im))) (/.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (.f64 #s(literal 2 binary64) (sinh.f64 im))))
(+.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (.f64 im #s(literal 2 binary64))))) (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (.f64 im #s(literal 2 binary64))))))
(+.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im)))))) (/.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im)))))))
(+.f64 (cosh.f64 im) (cosh.f64 im))
(+.f64 (exp.f64 (neg.f64 im)) (exp.f64 (neg.f64 (neg.f64 im))))
(+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))
(+.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(*.f64 (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))))
(*.f64 (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))))
(*.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)))
(pow.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) #s(literal -1/2 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) im)
(pow.f64 (exp.f64 im) #s(literal -1 binary64))
(/.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 (neg.f64 (exp.f64 im))))
(/.f64 #s(literal 1 binary64) (pow.f64 (exp.f64 im) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (exp.f64 im))
(/.f64 #s(literal -1 binary64) (neg.f64 (exp.f64 im)))
(-.f64 (cosh.f64 im) (sinh.f64 im))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) im))
(exp.f64 (neg.f64 im))
(+.f64 (cosh.f64 im) (sinh.f64 (neg.f64 im)))
#s(literal -1 binary64)
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (.f64 (*.f64 #s(literal 1/2 binary64) re) #s(literal 2 binary64)) (cosh.f64 im)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (.f64 (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal -1/12 binary64)) (.f64 re re))) re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal -1/12 binary64) (.f64 (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/240 binary64)) (.f64 re re))) (*.f64 re re))) re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal -1/12 binary64) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/240 binary64) (.f64 (.f64 #s(literal -1/10080 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64))) (.f64 re re))) (.f64 re re))) (.f64 re re))) re))
#s(approx (* 1/2 (sin re)) (*.f64 #s(literal 1/2 binary64) re))
#s(approx (* 1/2 (sin re)) (.f64 (fma.f64 #s(literal -1/12 binary64) (.f64 re re) #s(literal 1/2 binary64)) re))
#s(approx (* 1/2 (sin re)) (.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))
#s(approx (* 1/2 (sin re)) (.f64 (fma.f64 (-.f64 (.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))
#s(approx (sin re) re)
#s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re))
#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 (sin re) (.f64 (fma.f64 (-.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)) (*.f64 re re) #s(literal 1 binary64)) re))
#s(approx re re)
#s(approx (* (* (sin re) 1/2) (exp (neg im))) (.f64 (.f64 (exp.f64 (neg.f64 im)) re) #s(literal 1/2 binary64)))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) (.f64 (fma.f64 (.f64 (.f64 re re) (exp.f64 (neg.f64 im))) #s(literal -1/12 binary64) (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64))) re))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) (.f64 (fma.f64 (fma.f64 (.f64 (.f64 re re) (exp.f64 (neg.f64 im))) #s(literal 1/240 binary64) (.f64 #s(literal -1/12 binary64) (exp.f64 (neg.f64 im)))) (.f64 re re) (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64))) re))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) (.f64 (fma.f64 (fma.f64 (fma.f64 (.f64 (.f64 re re) (exp.f64 (neg.f64 im))) #s(literal -1/10080 binary64) (.f64 #s(literal 1/240 binary64) (exp.f64 (neg.f64 im)))) (.f64 re re) (.f64 #s(literal -1/12 binary64) (exp.f64 (neg.f64 im)))) (.f64 re re) (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64))) re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (.f64 (*.f64 #s(literal 1/2 binary64) re) #s(literal 2 binary64)) (cosh.f64 im)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 re re)) (.f64 (cosh.f64 im) #s(literal 2 binary64)))) re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (fma.f64 (fma.f64 (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 re re)) #s(literal 1/240 binary64) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal -1/12 binary64))) (.f64 re re) (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal -1/12 binary64) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/240 binary64) (.f64 (.f64 #s(literal -1/10080 binary64) (.f64 re re)) (.f64 (cosh.f64 im) #s(literal 2 binary64)))) (.f64 re re))) (.f64 re re))) re))
#s(approx (* (* re 1/2) (* 2 (cosh im))) (.f64 (.f64 (*.f64 #s(literal 1/2 binary64) re) #s(literal 2 binary64)) (cosh.f64 im)))
#s(approx (* re 1/2) (*.f64 #s(literal 1/2 binary64) re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (.f64 (*.f64 #s(literal 1/2 binary64) re) #s(literal 2 binary64)) (cosh.f64 im)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 re re)) (.f64 (cosh.f64 im) #s(literal 2 binary64)))) re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (fma.f64 (fma.f64 (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 re re)) #s(literal 1/240 binary64) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal -1/12 binary64))) (.f64 re re) (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal -1/12 binary64) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/240 binary64) (.f64 (.f64 #s(literal -1/10080 binary64) (.f64 re re)) (.f64 (cosh.f64 im) #s(literal 2 binary64)))) (.f64 re re))) (.f64 re re))) re))
#s(approx (* (* 2 (cosh im)) (sin re)) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) re))
#s(approx (* (* 2 (cosh im)) (sin re)) (.f64 (+.f64 (fma.f64 (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 re re)) #s(literal -1/6 binary64) (exp.f64 (neg.f64 im))) (exp.f64 im)) re))
#s(approx (* (* 2 (cosh im)) (sin re)) (.f64 (+.f64 (fma.f64 (fma.f64 (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 re re)) #s(literal 1/120 binary64) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal -1/6 binary64))) (*.f64 re re) (exp.f64 (neg.f64 im))) (exp.f64 im)) re))
#s(approx (* (* 2 (cosh im)) (sin re)) (.f64 (+.f64 (fma.f64 (fma.f64 (fma.f64 (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 re re)) #s(literal -1/5040 binary64) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/120 binary64))) (.f64 re re) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal -1/6 binary64))) (.f64 re re) (exp.f64 (neg.f64 im))) (exp.f64 im)) re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (.f64 (*.f64 #s(literal 1/2 binary64) re) #s(literal 2 binary64)) (cosh.f64 im)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (.f64 (.f64 #s(literal -1/12 binary64) (.f64 re re)) (.f64 (cosh.f64 im) #s(literal 2 binary64)))) re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (fma.f64 (fma.f64 (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 re re)) #s(literal 1/240 binary64) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal -1/12 binary64))) (.f64 re re) (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal -1/12 binary64) (.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/240 binary64) (.f64 (.f64 #s(literal -1/10080 binary64) (.f64 re re)) (.f64 (cosh.f64 im) #s(literal 2 binary64)))) (.f64 re re))) (.f64 re re))) re))
#s(approx (* 1/2 (sin re)) (*.f64 #s(literal 1/2 binary64) re))
#s(approx (* 1/2 (sin re)) (.f64 (fma.f64 #s(literal -1/12 binary64) (.f64 re re) #s(literal 1/2 binary64)) re))
#s(approx (* 1/2 (sin re)) (.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))
#s(approx (* 1/2 (sin re)) (.f64 (fma.f64 (-.f64 (.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))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (* 1/2 (sin re)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
#s(approx (sin re) (sin.f64 re))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (* (* 2 (cosh im)) (sin re)) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (sin.f64 re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (* 1/2 (sin re)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (sin.f64 re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (fma.f64 (*.f64 (sin.f64 re) #s(literal 0 binary64)) im (sin.f64 re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (fma.f64 (fma.f64 (sin.f64 re) #s(literal 0 binary64) (.f64 (.f64 (sin.f64 re) im) #s(literal 1/2 binary64))) im (sin.f64 re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (fma.f64 (fma.f64 (sin.f64 re) #s(literal 0 binary64) (.f64 (fma.f64 (.f64 (sin.f64 re) #s(literal 0 binary64)) im (*.f64 (sin.f64 re) #s(literal 1/2 binary64))) im)) im (sin.f64 re)))
#s(approx (exp im) #s(literal 1 binary64))
#s(approx (exp im) (+.f64 #s(literal 1 binary64) im))
#s(approx (exp im) (fma.f64 (fma.f64 im #s(literal 1/2 binary64) #s(literal 1 binary64)) im #s(literal 1 binary64)))
#s(approx (exp 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)))
#s(approx im im)
#s(approx (* (* (sin re) 1/2) (exp (neg im))) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) (fma.f64 (.f64 (sin.f64 re) im) #s(literal -1/2 binary64) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) (fma.f64 (fma.f64 #s(literal 1/4 binary64) (.f64 (sin.f64 re) im) (.f64 #s(literal -1/2 binary64) (sin.f64 re))) im (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/4 binary64) (sin.f64 re) (.f64 (.f64 (sin.f64 re) im) #s(literal -1/12 binary64))) im (.f64 #s(literal -1/2 binary64) (sin.f64 re))) im (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (pow (exp im) -1) #s(literal 1 binary64))
#s(approx (pow (exp im) -1) (fma.f64 #s(literal -1 binary64) im #s(literal 1 binary64)))
#s(approx (pow (exp im) -1) (fma.f64 (-.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64)) im #s(literal 1 binary64)))
#s(approx (pow (exp 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)))
#s(approx (neg im) (neg.f64 im))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (sin.f64 re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (fma.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) (sin.f64 re) (sin.f64 re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (fma.f64 (fma.f64 (.f64 #s(literal 1/24 binary64) (.f64 im im)) (sin.f64 re) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/720 binary64) (.f64 im im)) (sin.f64 re) (.f64 #s(literal 1/24 binary64) (sin.f64 re))) (.f64 im im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (* (* re 1/2) (* 2 (cosh im))) re)
#s(approx (* (* re 1/2) (* 2 (cosh im))) (fma.f64 (.f64 (.f64 im im) re) #s(literal 1/2 binary64) re))
#s(approx (* (* re 1/2) (* 2 (cosh im))) (fma.f64 (fma.f64 (.f64 (.f64 im im) re) #s(literal 1/24 binary64) (.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (* (* re 1/2) (* 2 (cosh im))) (fma.f64 (fma.f64 (fma.f64 (.f64 (.f64 im im) re) #s(literal 1/720 binary64) (.f64 #s(literal 1/24 binary64) re)) (.f64 im im) (.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (* 2 (cosh im)) #s(literal 2 binary64))
#s(approx (* 2 (cosh im)) (fma.f64 im im #s(literal 2 binary64)))
#s(approx (* 2 (cosh im)) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/12 binary64) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64)))
#s(approx (* 2 (cosh 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 (cosh im) #s(literal 1 binary64))
#s(approx (cosh im) (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)))
#s(approx (cosh im) (fma.f64 (fma.f64 #s(literal 1/24 binary64) (.f64 im im) #s(literal 1/2 binary64)) (.f64 im im) #s(literal 1 binary64)))
#s(approx (cosh im) (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)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (sin.f64 re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (fma.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) (sin.f64 re) (sin.f64 re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (fma.f64 (fma.f64 (.f64 #s(literal 1/24 binary64) (.f64 im im)) (sin.f64 re) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/720 binary64) (.f64 im im)) (sin.f64 re) (.f64 #s(literal 1/24 binary64) (sin.f64 re))) (.f64 im im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (* (* 2 (cosh im)) (sin re)) (*.f64 #s(literal 2 binary64) (sin.f64 re)))
#s(approx (* (* 2 (cosh im)) (sin re)) (*.f64 (sin.f64 re) (fma.f64 im im #s(literal 2 binary64))))
#s(approx (* (* 2 (cosh im)) (sin re)) (fma.f64 (fma.f64 (.f64 (.f64 im im) #s(literal 1/12 binary64)) (sin.f64 re) (sin.f64 re)) (.f64 im im) (.f64 #s(literal 2 binary64) (sin.f64 re))))
#s(approx (* (* 2 (cosh im)) (sin re)) (fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/360 binary64) (.f64 im im)) (sin.f64 re) (.f64 #s(literal 1/12 binary64) (sin.f64 re))) (.f64 im im) (sin.f64 re)) (.f64 im im) (.f64 #s(literal 2 binary64) (sin.f64 re))))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (sin.f64 re))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (fma.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) (sin.f64 re) (sin.f64 re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (fma.f64 (fma.f64 (.f64 #s(literal 1/24 binary64) (.f64 im im)) (sin.f64 re) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/720 binary64) (.f64 im im)) (sin.f64 re) (.f64 #s(literal 1/24 binary64) (sin.f64 re))) (.f64 im im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (* 2 (cosh im)) #s(literal 2 binary64))
#s(approx (* 2 (cosh im)) (fma.f64 im im #s(literal 2 binary64)))
#s(approx (* 2 (cosh im)) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/12 binary64) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64)))
#s(approx (* 2 (cosh 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 (pow (exp im) -1) #s(literal 1 binary64))
#s(approx (pow (exp im) -1) (fma.f64 #s(literal -1 binary64) im #s(literal 1 binary64)))
#s(approx (pow (exp im) -1) (fma.f64 (-.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64)) im #s(literal 1 binary64)))
#s(approx (pow (exp 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)))
#s(approx (exp im) (exp.f64 im))
#s(approx (pow (exp im) -1) (exp.f64 (neg.f64 im)))
#s(approx (* 2 (cosh im)) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))
#s(approx (cosh im) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
#s(approx (* 2 (cosh im)) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))
#s(approx (pow (exp im) -1) (exp.f64 (neg.f64 im)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (* (* (sin re) 1/2) (exp (neg im))) (.f64 (.f64 (exp.f64 (neg.f64 im)) #s(literal 1/2 binary64)) (sin.f64 re)))
#s(approx (pow (exp im) -1) (exp.f64 (neg.f64 im)))
#s(approx (* (* (* 2 (cosh im)) (sin re)) 1/2) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))

eval35.0ms (1.1%)

Memory: 4.0MiB live, 91.8MiB allocated; 10ms collecting garbage
Compiler: Compiled 7 422 to 1 065 computations (85.7% saved)

prune11.0ms (0.4%)

Memory

-19.5MiB live, 27.6MiB allocated; 3ms collecting garbage

Pruning

8 alts after pruning (5 fresh and 3 done)

	Pruned	Kept	Total
New	290	4	294
Fresh	0	1	1
Picked	2	3	5
Done	0	0	0
Total	292	8	300

Accuracy

100.0%

Counts

300 → 8

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	100.0%	(.f64 (fma.f64 (sin.f64 re) (exp.f64 im) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))) #s(literal 1/2 binary64))
✓	100.0%	(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
▶	53.1%	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (-.f64 (+.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 im)))
▶	62.8%	(.f64 (.f64 #s(literal 1/2 binary64) #s(approx (sin re) re)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -1 binary64)) (exp.f64 im)))
✓	62.8%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
✓	52.9%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin.f64 re))
▶	30.0%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (* re 1/2) (* 2 (cosh im))) re))
▶	37.5%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re)))

Compiler

Compiled 219 to 176 computations (19.6% saved)

series116.0ms (3.8%)

Memory

-25.0MiB live, 61.3MiB allocated; 62ms collecting garbage

Counts

31 → 127

Calls

Call 1

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

Outputs
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* 1/2 (* re (+ (exp im) (exp (neg im)))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* re (+ (* 1/2 (* (pow re 2) (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im)))))) (* 1/2 (+ (exp im) (exp (neg im))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (+ (* 1/120 (exp im)) (* 1/120 (exp (neg im)))))) (* 1/2 (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im)))))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* 1/2 (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (+ (* -1/5040 (exp im)) (* -1/5040 (exp (neg im)))))) (* 1/2 (+ (* 1/120 (exp im)) (* 1/120 (exp (neg im)))))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (exp (neg im))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp im)) (+ (* -1/6 (exp (neg im))) (* (pow re 2) (+ (* 1/120 (exp im)) (* 1/120 (exp (neg im)))))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp im)) (+ (* -1/6 (exp (neg im))) (* (pow re 2) (+ (* 1/120 (exp im)) (+ (* 1/120 (exp (neg im))) (* (pow re 2) (+ (* -1/5040 (exp im)) (* -1/5040 (exp (neg im))))))))))))))))
#s(approx (sin re) #s(hole binary64 re))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))))
#s(approx re #s(hole binary64 re))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (exp (neg im)))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (+ (exp (neg im)) (* -1/6 (* (pow re 2) (exp (neg im))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp (neg im))) (* 1/120 (* (pow re 2) (exp (neg im))))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp (neg im))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (exp (neg im)))) (* 1/120 (exp (neg im)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (exp (neg im)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole 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)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 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))))))))))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 re))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 1))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 (+ 1 (* -1/6 (pow re 2)))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/2 (+ (exp im) (/ 1 (exp im))))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 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)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 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))))))))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* 1/2 re)))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* -1/12 (pow re 2))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (* 1/2 (* re (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im))))))) (* 1/2 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im))))))))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (* re (+ (* 1/2 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))) (* 1/240 (* (pow re 2) (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))))))))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (* re (+ (* 1/2 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im))))))) (* 1/240 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im))))))))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* 1/2 (+ (* (exp im) (sin re)) (* (exp (neg im)) (sin re))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* (exp im) (sin re)) (* (exp (neg im)) (sin re)))))
#s(approx (sin re) #s(hole binary64 (sin re)))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* (exp (neg im)) (sin re))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* -1/6 (pow re 3))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* (pow re 3) (- (/ 1 (pow re 2)) 1/6))))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 (* -1/6 (pow re 2))))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 (* (pow re 2) (- (/ 1 (pow re 2)) 1/6))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* 1/2 (sin re))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (* 1/2 (* (sin re) (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* -1 (* (pow re 3) (- 1/6 (/ 1 (pow re 2)))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (sin re)))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (+ (sin re) (* 1/2 (* im (+ (sin re) (* -1 (sin re))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (+ (sin re) (* im (+ (* 1/2 (* im (sin re))) (* 1/2 (+ (sin re) (* -1 (sin re)))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (+ (sin re) (* im (+ (* 1/2 (+ (sin re) (* -1 (sin re)))) (* im (+ (* 1/2 (sin re)) (* 1/2 (* im (+ (* -1/6 (sin re)) (* 1/6 (sin re))))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* 2 (sin re))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* 2 (sin re)) (* im (+ (sin re) (* -1 (sin re)))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* 2 (sin re)) (* im (+ (sin re) (+ (* -1 (sin re)) (* im (sin re))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* 2 (sin re)) (* im (+ (sin re) (+ (* -1 (sin re)) (* im (+ (sin re) (* im (+ (* -1/6 (sin re)) (* 1/6 (sin re))))))))))))
#s(approx (exp im) #s(hole binary64 1))
#s(approx (exp im) #s(hole binary64 (+ 1 im)))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* 1/2 im))))))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))))
#s(approx im #s(hole binary64 im))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (sin re)))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (+ (sin re) (* -1 (* im (sin re))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (+ (sin re) (* im (+ (* -1 (sin re)) (* 1/2 (* im (sin re))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (+ (sin re) (* im (+ (* -1 (sin re)) (* im (+ (* -1/6 (* im (sin re))) (* 1/2 (sin re)))))))))
#s(approx (exp (neg im)) #s(hole binary64 1))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* -1 im))))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* im (- (* 1/2 im) 1)))))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 re))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (+ re (* 1/2 (* (pow im 2) re)))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* 1/24 (* (pow im 2) re)) (* 1/2 re))))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* 1/2 re) (* (pow im 2) (+ (* 1/720 (* (pow im 2) re)) (* 1/24 re))))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 2))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ 2 (pow im 2))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))))
#s(approx (pow (exp im) -1) #s(hole binary64 1))
#s(approx (pow (exp im) -1) #s(hole binary64 (+ 1 (* -1 im))))
#s(approx (pow (exp im) -1) #s(hole binary64 (+ 1 (* im (- (* 1/2 im) 1)))))
#s(approx (pow (exp im) -1) #s(hole binary64 (+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) #s(hole binary64 2))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) #s(hole binary64 (+ 2 (pow im 2))))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))))
#s(approx (+ (exp im) (cosh im)) #s(hole binary64 2))
#s(approx (+ (exp im) (cosh im)) #s(hole binary64 (+ 2 im)))
#s(approx (+ (exp im) (cosh im)) #s(hole binary64 (+ 2 (* im (+ 1 im)))))
#s(approx (+ (exp im) (cosh im)) #s(hole binary64 (+ 2 (* im (+ 1 (* im (+ 1 (* 1/6 im))))))))
#s(approx (cosh im) #s(hole binary64 1))
#s(approx (cosh im) #s(hole binary64 (+ 1 (* 1/2 (pow im 2)))))
#s(approx (cosh im) #s(hole binary64 (+ 1 (* (pow im 2) (+ 1/2 (* 1/24 (pow im 2)))))))
#s(approx (cosh im) #s(hole binary64 (+ 1 (* (pow im 2) (+ 1/2 (* (pow im 2) (+ 1/24 (* 1/720 (pow im 2)))))))))
#s(approx (sinh im) #s(hole binary64 im))
#s(approx (sinh im) #s(hole binary64 (* im (+ 1 (* 1/6 (pow im 2))))))
#s(approx (sinh im) #s(hole binary64 (* im (+ 1 (* (pow im 2) (+ 1/6 (* 1/120 (pow im 2))))))))
#s(approx (sinh im) #s(hole binary64 (* im (+ 1 (* (pow im 2) (+ 1/6 (* (pow im 2) (+ 1/120 (* 1/5040 (pow im 2))))))))))
#s(approx (exp im) #s(hole binary64 (exp im)))
#s(approx (exp (neg im)) #s(hole binary64 (exp (neg im))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ (exp im) (/ 1 (exp im)))))
#s(approx (pow (exp im) -1) #s(hole binary64 (/ 1 (exp im))))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) #s(hole binary64 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))))
#s(approx (+ (exp im) (cosh im)) #s(hole binary64 (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im)))))))
#s(approx (cosh im) #s(hole binary64 (* 1/2 (+ (exp im) (/ 1 (exp im))))))
#s(approx (sinh im) #s(hole binary64 (* 1/2 (- (exp im) (/ 1 (exp im))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* 1/2 (+ (* (exp im) (sin re)) (* (exp (* -1 im)) (sin re))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* (exp im) (sin re)) (* (exp (* -1 im)) (sin re)))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* (exp (* -1 im)) (sin re))))
#s(approx (exp (neg im)) #s(hole binary64 (exp (* -1 im))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))))

Calls

6 calls:

Time	Variable		Point	Expression
90.0ms	im	@	inf	((* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (sin re) re (exp im) im (* (exp (neg im)) (sin re)) (exp (neg im)) (neg im) 1/2 (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* re 1/2) (* 2 (cosh im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (+ (* -1/6 (* re re)) 1) -1/6 (* re re) 1 (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) (* 1/2 (sin re)) (sin re) (+ (pow (exp im) -1) (exp im)) (pow (exp im) -1) -1 (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im)) (+ (exp im) (cosh im)) (cosh im) (sinh im))
10.0ms	im	@	-inf	((* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (sin re) re (exp im) im (* (exp (neg im)) (sin re)) (exp (neg im)) (neg im) 1/2 (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* re 1/2) (* 2 (cosh im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (+ (* -1/6 (* re re)) 1) -1/6 (* re re) 1 (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) (* 1/2 (sin re)) (sin re) (+ (pow (exp im) -1) (exp im)) (pow (exp im) -1) -1 (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im)) (+ (exp im) (cosh im)) (cosh im) (sinh im))
4.0ms	re	@	inf	((* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (sin re) re (exp im) im (* (exp (neg im)) (sin re)) (exp (neg im)) (neg im) 1/2 (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* re 1/2) (* 2 (cosh im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (+ (* -1/6 (* re re)) 1) -1/6 (* re re) 1 (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) (* 1/2 (sin re)) (sin re) (+ (pow (exp im) -1) (exp im)) (pow (exp im) -1) -1 (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im)) (+ (exp im) (cosh im)) (cosh im) (sinh im))
4.0ms	re	@	-inf	((* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (sin re) re (exp im) im (* (exp (neg im)) (sin re)) (exp (neg im)) (neg im) 1/2 (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* re 1/2) (* 2 (cosh im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (+ (* -1/6 (* re re)) 1) -1/6 (* re re) 1 (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) (* 1/2 (sin re)) (sin re) (+ (pow (exp im) -1) (exp im)) (pow (exp im) -1) -1 (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im)) (+ (exp im) (cosh im)) (cosh im) (sinh im))
4.0ms	re	@	0	((* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (sin re) re (exp im) im (* (exp (neg im)) (sin re)) (exp (neg im)) (neg im) 1/2 (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (* (* re 1/2) (* 2 (cosh im))) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (+ (* -1/6 (* re re)) 1) -1/6 (* re re) 1 (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) (* 1/2 (sin re)) (sin re) (+ (pow (exp im) -1) (exp im)) (pow (exp im) -1) -1 (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im)) (+ (exp im) (cosh im)) (cosh im) (sinh im))

rewrite324.0ms (10.5%)

Memory

4.9MiB live, 329.1MiB allocated; 34ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	530	3227
0	565	2723
1	3387	2697
0	11985	2560

Stop Event

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

Counts

158 → 397

Calls

Call 1

Inputs
(.f64 (fma.f64 (sin.f64 re) (exp.f64 im) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))) #s(literal 1/2 binary64))
(fma.f64 (sin.f64 re) (exp.f64 im) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))
(sin.f64 re)
re
(exp.f64 im)
im
(*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))
(exp.f64 (neg.f64 im))
(neg.f64 im)
#s(literal 1/2 binary64)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (* re 1/2) (* 2 (cosh im))) re))
#s(approx (* (* re 1/2) (* 2 (cosh im))) re)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re)))
#s(approx (sin re) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re))
(.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 re re) #s(literal 1 binary64)) re)
(fma.f64 #s(literal -1/6 binary64) (*.f64 re re) #s(literal 1 binary64))
#s(literal -1/6 binary64)
(*.f64 re re)
#s(literal 1 binary64)
(.f64 (.f64 #s(literal 1/2 binary64) #s(approx (sin re) re)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -1 binary64)) (exp.f64 im)))
(*.f64 #s(literal 1/2 binary64) #s(approx (sin re) re))
#s(approx (sin re) re)
(+.f64 (pow.f64 (exp.f64 im) #s(literal -1 binary64)) (exp.f64 im))
(pow.f64 (exp.f64 im) #s(literal -1 binary64))
#s(literal -1 binary64)
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (-.f64 (+.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 im)))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
(-.f64 (+.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 im))
(+.f64 (exp.f64 im) (cosh.f64 im))
(cosh.f64 im)
(sinh.f64 im)
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* 1/2 (* re (+ (exp im) (exp (neg im)))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* re (+ (* 1/2 (* (pow re 2) (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im)))))) (* 1/2 (+ (exp im) (exp (neg im))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (+ (* 1/120 (exp im)) (* 1/120 (exp (neg im)))))) (* 1/2 (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im)))))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* 1/2 (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (+ (* -1/5040 (exp im)) (* -1/5040 (exp (neg im)))))) (* 1/2 (+ (* 1/120 (exp im)) (* 1/120 (exp (neg im)))))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (exp (neg im))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp im)) (+ (* -1/6 (exp (neg im))) (* (pow re 2) (+ (* 1/120 (exp im)) (* 1/120 (exp (neg im)))))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp im)) (+ (* -1/6 (exp (neg im))) (* (pow re 2) (+ (* 1/120 (exp im)) (+ (* 1/120 (exp (neg im))) (* (pow re 2) (+ (* -1/5040 (exp im)) (* -1/5040 (exp (neg im))))))))))))))))
#s(approx (sin re) #s(hole binary64 re))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))))
#s(approx re #s(hole binary64 re))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (exp (neg im)))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (+ (exp (neg im)) (* -1/6 (* (pow re 2) (exp (neg im))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp (neg im))) (* 1/120 (* (pow re 2) (exp (neg im))))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp (neg im))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (exp (neg im)))) (* 1/120 (exp (neg im)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (exp (neg im)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole 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)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 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))))))))))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 re))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 1))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 (+ 1 (* -1/6 (pow re 2)))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (/ 1 (exp im))))) (* 1/2 (+ (exp im) (/ 1 (exp im))))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 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)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 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))))))))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* 1/2 re)))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* -1/12 (pow re 2))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* 1/240 (pow re 2)) 1/12))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* re (+ 1/2 (* (pow re 2) (- (* (pow re 2) (+ 1/240 (* -1/10080 (pow re 2)))) 1/12))))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (* 1/2 (* re (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im))))))) (* 1/2 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im))))))))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (* re (+ (* 1/2 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))) (* 1/240 (* (pow re 2) (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))))))))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (* re (+ (* 1/2 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))) (* (pow re 2) (+ (* -1/12 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))) (* (pow re 2) (+ (* -1/10080 (* (pow re 2) (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im))))))) (* 1/240 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im))))))))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* 1/2 (+ (* (exp im) (sin re)) (* (exp (neg im)) (sin re))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* (exp im) (sin re)) (* (exp (neg im)) (sin re)))))
#s(approx (sin re) #s(hole binary64 (sin re)))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* (exp (neg im)) (sin re))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* -1/6 (pow re 3))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* (pow re 3) (- (/ 1 (pow re 2)) 1/6))))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 (* -1/6 (pow re 2))))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 (* (pow re 2) (- (/ 1 (pow re 2)) 1/6))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (/ 1 (exp im)))))))
#s(approx (* 1/2 (sin re)) #s(hole binary64 (* 1/2 (sin re))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (* 1/2 (* (sin re) (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* -1 (* (pow re 3) (- 1/6 (/ 1 (pow re 2)))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (sin re)))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (+ (sin re) (* 1/2 (* im (+ (sin re) (* -1 (sin re))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (+ (sin re) (* im (+ (* 1/2 (* im (sin re))) (* 1/2 (+ (sin re) (* -1 (sin re)))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (+ (sin re) (* im (+ (* 1/2 (+ (sin re) (* -1 (sin re)))) (* im (+ (* 1/2 (sin re)) (* 1/2 (* im (+ (* -1/6 (sin re)) (* 1/6 (sin re))))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* 2 (sin re))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* 2 (sin re)) (* im (+ (sin re) (* -1 (sin re)))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* 2 (sin re)) (* im (+ (sin re) (+ (* -1 (sin re)) (* im (sin re))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* 2 (sin re)) (* im (+ (sin re) (+ (* -1 (sin re)) (* im (+ (sin re) (* im (+ (* -1/6 (sin re)) (* 1/6 (sin re))))))))))))
#s(approx (exp im) #s(hole binary64 1))
#s(approx (exp im) #s(hole binary64 (+ 1 im)))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* 1/2 im))))))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))))
#s(approx im #s(hole binary64 im))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (sin re)))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (+ (sin re) (* -1 (* im (sin re))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (+ (sin re) (* im (+ (* -1 (sin re)) (* 1/2 (* im (sin re))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (+ (sin re) (* im (+ (* -1 (sin re)) (* im (+ (* -1/6 (* im (sin re))) (* 1/2 (sin re)))))))))
#s(approx (exp (neg im)) #s(hole binary64 1))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* -1 im))))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* im (- (* 1/2 im) 1)))))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 re))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (+ re (* 1/2 (* (pow im 2) re)))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* 1/24 (* (pow im 2) re)) (* 1/2 re))))))
#s(approx (* (* re 1/2) (* 2 (cosh im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* 1/2 re) (* (pow im 2) (+ (* 1/720 (* (pow im 2) re)) (* 1/24 re))))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (+ (pow (exp im) -1) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 2))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ 2 (pow im 2))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))))
#s(approx (pow (exp im) -1) #s(hole binary64 1))
#s(approx (pow (exp im) -1) #s(hole binary64 (+ 1 (* -1 im))))
#s(approx (pow (exp im) -1) #s(hole binary64 (+ 1 (* im (- (* 1/2 im) 1)))))
#s(approx (pow (exp im) -1) #s(hole binary64 (+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) #s(hole binary64 2))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) #s(hole binary64 (+ 2 (pow im 2))))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* 1/12 (pow im 2)))))))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) #s(hole binary64 (+ 2 (* (pow im 2) (+ 1 (* (pow im 2) (+ 1/12 (* 1/360 (pow im 2)))))))))
#s(approx (+ (exp im) (cosh im)) #s(hole binary64 2))
#s(approx (+ (exp im) (cosh im)) #s(hole binary64 (+ 2 im)))
#s(approx (+ (exp im) (cosh im)) #s(hole binary64 (+ 2 (* im (+ 1 im)))))
#s(approx (+ (exp im) (cosh im)) #s(hole binary64 (+ 2 (* im (+ 1 (* im (+ 1 (* 1/6 im))))))))
#s(approx (cosh im) #s(hole binary64 1))
#s(approx (cosh im) #s(hole binary64 (+ 1 (* 1/2 (pow im 2)))))
#s(approx (cosh im) #s(hole binary64 (+ 1 (* (pow im 2) (+ 1/2 (* 1/24 (pow im 2)))))))
#s(approx (cosh im) #s(hole binary64 (+ 1 (* (pow im 2) (+ 1/2 (* (pow im 2) (+ 1/24 (* 1/720 (pow im 2)))))))))
#s(approx (sinh im) #s(hole binary64 im))
#s(approx (sinh im) #s(hole binary64 (* im (+ 1 (* 1/6 (pow im 2))))))
#s(approx (sinh im) #s(hole binary64 (* im (+ 1 (* (pow im 2) (+ 1/6 (* 1/120 (pow im 2))))))))
#s(approx (sinh im) #s(hole binary64 (* im (+ 1 (* (pow im 2) (+ 1/6 (* (pow im 2) (+ 1/120 (* 1/5040 (pow im 2))))))))))
#s(approx (exp im) #s(hole binary64 (exp im)))
#s(approx (exp (neg im)) #s(hole binary64 (exp (neg im))))
#s(approx (+ (pow (exp im) -1) (exp im)) #s(hole binary64 (+ (exp im) (/ 1 (exp im)))))
#s(approx (pow (exp im) -1) #s(hole binary64 (/ 1 (exp im))))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) #s(hole binary64 (- (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im))))) (* 1/2 (- (exp im) (/ 1 (exp im)))))))
#s(approx (+ (exp im) (cosh im)) #s(hole binary64 (+ (exp im) (* 1/2 (+ (exp im) (/ 1 (exp im)))))))
#s(approx (cosh im) #s(hole binary64 (* 1/2 (+ (exp im) (/ 1 (exp im))))))
#s(approx (sinh im) #s(hole binary64 (* 1/2 (- (exp im) (/ 1 (exp im))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* 1/2 (+ (* (exp im) (sin re)) (* (exp (* -1 im)) (sin re))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* (exp im) (sin re)) (* (exp (* -1 im)) (sin re)))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* (exp (* -1 im)) (sin re))))
#s(approx (exp (neg im)) #s(hole binary64 (exp (* -1 im))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))))

Outputs
(.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) (sin.f64 re)) #s(literal 1/2 binary64))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 (*.f64 (cosh.f64 im) #s(literal 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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64)) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)) (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)) (-.f64 (.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64)) (.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))) (.f64 (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)) (.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (pow.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (-.f64 (.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im))) (.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im))))))
(/.f64 (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re))) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))) #s(literal 3 binary64))) (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re))) (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re))) (-.f64 (.f64 (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))) (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))) (.f64 (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re))) (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))))))
(fma.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (*.f64 (exp.f64 (neg.f64 im)) (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 (exp.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 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)))
(fma.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re)) (.f64 #s(literal 1/2 binary64) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))))
(+.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)) (.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64)))
(+.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)))
(+.f64 (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re))) (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))))
(.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (sin.f64 re))
(.f64 (sin.f64 re) (.f64 (cosh.f64 im) #s(literal 2 binary64)))
(/.f64 (fma.f64 (pow.f64 (sin.f64 re) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) (.f64 (exp.f64 im) (sin.f64 re))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (exp.f64 im) (sin.f64 re)) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))))))
(/.f64 (-.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 2 binary64))) (-.f64 (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))))
(/.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64)) (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.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 (exp.f64 im) (sin.f64 re) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))
(fma.f64 (sin.f64 re) (exp.f64 (neg.f64 im)) (*.f64 (exp.f64 im) (sin.f64 re)))
(fma.f64 (sin.f64 re) (exp.f64 im) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))
(-.f64 (/.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))) (/.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))))
(-.f64 (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (neg.f64 (exp.f64 (neg.f64 im))) (sin.f64 re)))
(+.f64 (/.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))))) (/.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 2 binary64)) (.f64 (.f64 (exp.f64 im) (sin.f64 re)) (.f64 (exp.f64 (neg.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)))
(sin.f64 re)
re
(/.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 (cosh.f64 im) #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (sinh.f64 im))) #s(literal 2 binary64))
(/.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 2 binary64) (.f64 #s(literal 2 binary64) (*.f64 #s(literal 2 binary64) (sinh.f64 im)))) #s(literal 4 binary64))
(exp.f64 im)
(+.f64 (cosh.f64 im) (sinh.f64 im))
im
(*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))
(*.f64 (sin.f64 re) (exp.f64 (neg.f64 im)))
(*.f64 (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))))
(*.f64 (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))))
(*.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)))
(pow.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) #s(literal -1/2 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) im)
(pow.f64 (exp.f64 im) #s(literal -1 binary64))
(/.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 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (*.f64 (cosh.f64 im) (sinh.f64 (neg.f64 im))))))
(/.f64 (-.f64 (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 2 binary64)) (.f64 #s(literal 2 binary64) (.f64 #s(literal 2 binary64) (sinh.f64 im)))) #s(literal 4 binary64))
(/.f64 (-.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 #s(literal 2 binary64) (sinh.f64 im))) #s(literal 2 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (exp.f64 im)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (exp.f64 im))))
(/.f64 #s(literal 1 binary64) (pow.f64 (exp.f64 im) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (exp.f64 im))
(-.f64 (cosh.f64 im) (sinh.f64 im))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) im))
(exp.f64 (neg.f64 im))
(+.f64 (cosh.f64 im) (sinh.f64 (neg.f64 im)))
(*.f64 #s(literal -1 binary64) im)
(*.f64 im #s(literal -1 binary64))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) (neg.f64 (+.f64 #s(literal 0 binary64) im)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 0 binary64) (fma.f64 im im (*.f64 #s(literal 0 binary64) im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (+.f64 #s(literal 0 binary64) im))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 im im (*.f64 #s(literal 0 binary64) im))))
(neg.f64 im)
(-.f64 (/.f64 #s(literal 0 binary64) (+.f64 #s(literal 0 binary64) im)) (/.f64 (*.f64 im im) (+.f64 #s(literal 0 binary64) im)))
(-.f64 (/.f64 #s(literal 0 binary64) (+.f64 #s(literal 0 binary64) (fma.f64 im im (.f64 #s(literal 0 binary64) im)))) (/.f64 (pow.f64 im #s(literal 3 binary64)) (+.f64 #s(literal 0 binary64) (fma.f64 im im (.f64 #s(literal 0 binary64) im)))))
(-.f64 #s(literal 0 binary64) im)
#s(literal 1/2 binary64)
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(approx (* (* re 1/2) (* 2 (cosh im))) re))
#s(approx (* (* re 1/2) (* 2 (cosh im))) re)
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) #s(approx (sin re) (.f64 (fma.f64 (.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64)) re)))
#s(approx (sin re) (.f64 (fma.f64 (.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64)) re))
(.f64 (fma.f64 (.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64)) re)
(.f64 re (fma.f64 (.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64)))
(/.f64 (+.f64 (pow.f64 (.f64 #s(literal 1 binary64) re) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) re) #s(literal 3 binary64))) (fma.f64 (.f64 #s(literal 1 binary64) re) (.f64 #s(literal 1 binary64) re) (-.f64 (.f64 (.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) re) (.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) re)) (.f64 (.f64 #s(literal 1 binary64) re) (.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) re)))))
(/.f64 (+.f64 (pow.f64 (.f64 re #s(literal 1 binary64)) #s(literal 3 binary64)) (pow.f64 (.f64 re (.f64 (.f64 re re) #s(literal -1/6 binary64))) #s(literal 3 binary64))) (fma.f64 (.f64 re #s(literal 1 binary64)) (.f64 re #s(literal 1 binary64)) (-.f64 (.f64 (.f64 re (.f64 (.f64 re re) #s(literal -1/6 binary64))) (.f64 re (.f64 (.f64 re re) #s(literal -1/6 binary64)))) (.f64 (.f64 re #s(literal 1 binary64)) (.f64 re (.f64 (.f64 re re) #s(literal -1/6 binary64)))))))
(fma.f64 #s(literal 1 binary64) re (.f64 (.f64 (*.f64 re re) #s(literal -1/6 binary64)) re))
(fma.f64 re #s(literal 1 binary64) (.f64 re (.f64 (*.f64 re re) #s(literal -1/6 binary64))))
(+.f64 (.f64 #s(literal 1 binary64) re) (.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) re))
(+.f64 (.f64 re #s(literal 1 binary64)) (.f64 re (.f64 (.f64 re re) #s(literal -1/6 binary64))))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64)))) (neg.f64 (-.f64 #s(literal 1 binary64) (.f64 (.f64 re re) #s(literal -1/6 binary64)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64))) (neg.f64 (-.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(/.f64 (neg.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (.f64 (*.f64 re re) #s(literal -1/6 binary64)))))))
(/.f64 (neg.f64 (fma.f64 #s(literal -1/216 binary64) (pow.f64 (.f64 re re) #s(literal 3 binary64)) #s(literal 1 binary64))) (neg.f64 (+.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 1 binary64))))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64))) (-.f64 #s(literal 1 binary64) (.f64 (.f64 re re) #s(literal -1/6 binary64))))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)) (-.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 1 binary64)))
(/.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (.f64 (*.f64 re re) #s(literal -1/6 binary64))))))
(/.f64 (fma.f64 #s(literal -1/216 binary64) (pow.f64 (.f64 re re) #s(literal 3 binary64)) #s(literal 1 binary64)) (+.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 1 binary64)))))
(fma.f64 (*.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64))
(fma.f64 (*.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64))
(fma.f64 #s(literal -1/6 binary64) (*.f64 re re) #s(literal 1 binary64))
(-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (.f64 (.f64 re re) #s(literal -1/6 binary64)))) (/.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (.f64 re re) #s(literal -1/6 binary64)))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 1 binary64))))
(-.f64 #s(literal 1 binary64) (.f64 #s(literal 1/6 binary64) (.f64 re re)))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (.f64 (.f64 re re) #s(literal -1/6 binary64)))))) (/.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 3 binary64)) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (.f64 (.f64 re re) #s(literal -1/6 binary64)))))))
(+.f64 (/.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 1 binary64))))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 1 binary64))))))
(+.f64 (.f64 (.f64 re re) #s(literal -1/6 binary64)) #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) (.f64 (.f64 re re) #s(literal -1/6 binary64)))
#s(literal -1/6 binary64)
(*.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)))
(*.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)))
(*.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)))
(*.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 re re)
(pow.f64 (exp.f64 (log.f64 re)) #s(literal 2 binary64))
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (fabs.f64 re) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(fabs.f64 (*.f64 re re))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))))
#s(literal 1 binary64)
(.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)))
(.f64 (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 #s(approx (sin re) re) (*.f64 (cosh.f64 im) #s(literal 2 binary64))))
(/.f64 (+.f64 (pow.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (exp.f64 im) (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64))) #s(literal 3 binary64))) (fma.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64))) (.f64 (exp.f64 (neg.f64 im)) (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64))) (-.f64 (.f64 (.f64 (exp.f64 im) (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64))) (.f64 (exp.f64 im) (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)))) (.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64))) (.f64 (exp.f64 im) (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (exp.f64 im)) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (-.f64 (.f64 (.f64 (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (exp.f64 im)) (.f64 (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (exp.f64 im))) (.f64 (.f64 (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (exp.f64 im))))))
(fma.f64 (exp.f64 (neg.f64 im)) (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (.f64 (exp.f64 im) (*.f64 #s(approx (sin re) re) #s(literal 1/2 binary64))))
(fma.f64 (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im)) (.f64 (*.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (exp.f64 im)))
(+.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64))) (.f64 (exp.f64 im) (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64))))
(+.f64 (.f64 (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 #s(approx (sin re) re) #s(literal 1/2 binary64)) (exp.f64 im)))
(*.f64 #s(approx (sin re) re) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) #s(approx (sin re) re))
#s(approx (sin re) re)
(*.f64 (cosh.f64 im) #s(literal 2 binary64))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 (/.f64 (fma.f64 #s(literal -1 binary64) im (neg.f64 im)) #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 (fma.f64 #s(literal -1 binary64) 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))) (cosh.f64 (/.f64 (-.f64 im im) #s(literal 2 binary64)))))
(*.f64 #s(literal 2 binary64) (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 (cosh.f64 im) #s(literal 2 binary64) (*.f64 (cosh.f64 im) #s(literal 2 binary64))) #s(literal 2 binary64))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (sinh.f64 im) #s(literal 2 binary64)))) (neg.f64 (+.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (exp.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 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (pow.f64 (exp.f64 im) #s(literal -2 binary64)))) (neg.f64 (*.f64 #s(literal 2 binary64) (sinh.f64 im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 3 binary64)) (pow.f64 (sinh.f64 im) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (fma.f64 (sinh.f64 im) (sinh.f64 im) (*.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (*.f64 im #s(literal 2 binary64))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64)))) (neg.f64 (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im)))))))
(/.f64 (-.f64 (.f64 (-.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (pow.f64 (cosh.f64 im) #s(literal 2 binary64))) #s(literal 2 binary64)) (.f64 (-.f64 (exp.f64 im) (cosh.f64 im)) (.f64 #s(literal 2 binary64) (sinh.f64 im)))) (.f64 (-.f64 (exp.f64 im) (cosh.f64 im)) #s(literal 2 binary64)))
(/.f64 (-.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (cosh.f64 im) #s(literal 3 binary64))) #s(literal 2 binary64)) (.f64 (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 (exp.f64 im) (cosh.f64 im)))) (.f64 #s(literal 2 binary64) (sinh.f64 im)))) (.f64 (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 (exp.f64 im) (cosh.f64 im)))) #s(literal 2 binary64)))
(/.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 2 binary64) (.f64 #s(literal 2 binary64) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))) #s(literal 4 binary64))
(/.f64 (-.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (sinh.f64 im) #s(literal 2 binary64))) (+.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im)))
(/.f64 (-.f64 (pow.f64 (exp.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 2 binary64)) (pow.f64 (exp.f64 im) #s(literal -2 binary64))) (*.f64 #s(literal 2 binary64) (sinh.f64 im)))
(/.f64 (-.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 3 binary64)) (pow.f64 (sinh.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (fma.f64 (sinh.f64 im) (sinh.f64 im) (*.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im)))))
(/.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (*.f64 im #s(literal 2 binary64)))))
(/.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im))))))
(fma.f64 (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 (neg.f64 (neg.f64 im))))
(fma.f64 (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 im))
(fma.f64 (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 (neg.f64 (neg.f64 im))))
(fma.f64 (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 im))
(fma.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (exp.f64 (neg.f64 (neg.f64 im))))
(fma.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (exp.f64 im))
(-.f64 (/.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (+.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))) (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (+.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))))
(-.f64 (/.f64 (pow.f64 (exp.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 (exp.f64 im) #s(literal 2 binary64)) (.f64 #s(literal 2 binary64) (sinh.f64 im))) (/.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (.f64 #s(literal 2 binary64) (sinh.f64 im))))
(-.f64 (/.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 3 binary64)) (+.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (fma.f64 (sinh.f64 im) (sinh.f64 im) (.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))))) (/.f64 (pow.f64 (sinh.f64 im) #s(literal 3 binary64)) (+.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (fma.f64 (sinh.f64 im) (sinh.f64 im) (.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))))))
(-.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))
(+.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (.f64 im #s(literal 2 binary64))))) (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (.f64 im #s(literal 2 binary64))))))
(+.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im)))))) (/.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im)))))))
(+.f64 (exp.f64 (neg.f64 im)) (exp.f64 (neg.f64 (neg.f64 im))))
(+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))
(+.f64 (cosh.f64 im) (cosh.f64 im))
(+.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(*.f64 (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))))
(*.f64 (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))))
(*.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)))
(pow.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) #s(literal -1/2 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) im)
(pow.f64 (exp.f64 im) #s(literal -1 binary64))
(/.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 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (*.f64 (cosh.f64 im) (sinh.f64 (neg.f64 im))))))
(/.f64 (-.f64 (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 2 binary64)) (.f64 #s(literal 2 binary64) (.f64 #s(literal 2 binary64) (sinh.f64 im)))) #s(literal 4 binary64))
(/.f64 (-.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 #s(literal 2 binary64) (sinh.f64 im))) #s(literal 2 binary64))
(/.f64 #s(literal -1 binary64) (neg.f64 (exp.f64 im)))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (exp.f64 im))))
(/.f64 #s(literal 1 binary64) (pow.f64 (exp.f64 im) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (exp.f64 im))
(-.f64 (cosh.f64 im) (sinh.f64 im))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) im))
(exp.f64 (neg.f64 im))
(+.f64 (cosh.f64 im) (sinh.f64 (neg.f64 im)))
#s(literal -1 binary64)
(.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
(.f64 (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) (sin.f64 re)) #s(literal 1/2 binary64))
(.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 (*.f64 (cosh.f64 im) #s(literal 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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) #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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.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 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64)) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)) (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)) (-.f64 (.f64 (.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64)) (.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))) (.f64 (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)) (.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (pow.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)) #s(literal 3 binary64))) (fma.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (-.f64 (.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im))) (.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im))))))
(/.f64 (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re))) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))) #s(literal 3 binary64))) (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re))) (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re))) (-.f64 (.f64 (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))) (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))) (.f64 (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re))) (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))))))
(fma.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64) (.f64 (*.f64 (exp.f64 (neg.f64 im)) (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 (exp.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 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)))
(fma.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re)) (.f64 #s(literal 1/2 binary64) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))))
(+.f64 (.f64 (exp.f64 (neg.f64 im)) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 (exp.f64 im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))))
(+.f64 (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 1/2 binary64)) (.f64 (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64)))
(+.f64 (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im)))
(+.f64 (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 im) (sin.f64 re))) (.f64 #s(literal 1/2 binary64) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))))
(*.f64 (sin.f64 re) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
(*.f64 (cosh.f64 im) #s(literal 2 binary64))
(.f64 #s(literal 2 binary64) (.f64 (cosh.f64 (/.f64 (fma.f64 #s(literal -1 binary64) im (neg.f64 im)) #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 (fma.f64 #s(literal -1 binary64) 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))) (cosh.f64 (/.f64 (-.f64 im im) #s(literal 2 binary64)))))
(*.f64 #s(literal 2 binary64) (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 (cosh.f64 im) #s(literal 2 binary64) (*.f64 (cosh.f64 im) #s(literal 2 binary64))) #s(literal 2 binary64))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (sinh.f64 im) #s(literal 2 binary64)))) (neg.f64 (+.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (exp.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 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (pow.f64 (exp.f64 im) #s(literal -2 binary64)))) (neg.f64 (*.f64 #s(literal 2 binary64) (sinh.f64 im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 3 binary64)) (pow.f64 (sinh.f64 im) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (fma.f64 (sinh.f64 im) (sinh.f64 im) (*.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (*.f64 im #s(literal 2 binary64))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64)))) (neg.f64 (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im)))))))
(/.f64 (-.f64 (.f64 (-.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (pow.f64 (cosh.f64 im) #s(literal 2 binary64))) #s(literal 2 binary64)) (.f64 (-.f64 (exp.f64 im) (cosh.f64 im)) (.f64 #s(literal 2 binary64) (sinh.f64 im)))) (.f64 (-.f64 (exp.f64 im) (cosh.f64 im)) #s(literal 2 binary64)))
(/.f64 (-.f64 (.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (cosh.f64 im) #s(literal 3 binary64))) #s(literal 2 binary64)) (.f64 (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 (exp.f64 im) (cosh.f64 im)))) (.f64 #s(literal 2 binary64) (sinh.f64 im)))) (.f64 (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 (exp.f64 im) (cosh.f64 im)))) #s(literal 2 binary64)))
(/.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 2 binary64) (.f64 #s(literal 2 binary64) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))) #s(literal 4 binary64))
(/.f64 (-.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (pow.f64 (sinh.f64 im) #s(literal 2 binary64))) (+.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im)))
(/.f64 (-.f64 (pow.f64 (exp.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 2 binary64)) (pow.f64 (exp.f64 im) #s(literal -2 binary64))) (*.f64 #s(literal 2 binary64) (sinh.f64 im)))
(/.f64 (-.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 3 binary64)) (pow.f64 (sinh.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (fma.f64 (sinh.f64 im) (sinh.f64 im) (*.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im)))))
(/.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (*.f64 im #s(literal 2 binary64)))))
(/.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal -3 binary64))) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im))))))
(fma.f64 (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 (neg.f64 (neg.f64 im))))
(fma.f64 (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (neg.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 im))
(fma.f64 (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 (neg.f64 (neg.f64 im))))
(fma.f64 (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (fabs.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64))) (exp.f64 im))
(fma.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (exp.f64 (neg.f64 (neg.f64 im))))
(fma.f64 (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (pow.f64 (exp.f64 im) #s(literal -1/2 binary64)) (exp.f64 im))
(-.f64 (/.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (+.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))) (/.f64 (pow.f64 (sinh.f64 im) #s(literal 2 binary64)) (+.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))))
(-.f64 (/.f64 (pow.f64 (exp.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 (exp.f64 im) #s(literal 2 binary64)) (.f64 #s(literal 2 binary64) (sinh.f64 im))) (/.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (.f64 #s(literal 2 binary64) (sinh.f64 im))))
(-.f64 (/.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 3 binary64)) (+.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (fma.f64 (sinh.f64 im) (sinh.f64 im) (.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))))) (/.f64 (pow.f64 (sinh.f64 im) #s(literal 3 binary64)) (+.f64 (pow.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (fma.f64 (sinh.f64 im) (sinh.f64 im) (.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))))))
(-.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) (sinh.f64 im))
(+.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (.f64 im #s(literal 2 binary64))))) (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (expm1.f64 (.f64 im #s(literal 2 binary64))))))
(+.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im)))))) (/.f64 (pow.f64 (exp.f64 im) #s(literal -3 binary64)) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal -2 binary64)) (exp.f64 (+.f64 im (neg.f64 im)))))))
(+.f64 (exp.f64 (neg.f64 im)) (exp.f64 (neg.f64 (neg.f64 im))))
(+.f64 (exp.f64 (neg.f64 im)) (exp.f64 im))
(+.f64 (cosh.f64 im) (cosh.f64 im))
(+.f64 (exp.f64 im) (exp.f64 (neg.f64 im)))
(/.f64 (+.f64 (pow.f64 (cosh.f64 im) #s(literal 3 binary64)) (pow.f64 (exp.f64 im) #s(literal 3 binary64))) (fma.f64 (cosh.f64 im) (cosh.f64 im) (-.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (*.f64 (cosh.f64 im) (exp.f64 im)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (pow.f64 (cosh.f64 im) #s(literal 2 binary64)))) (neg.f64 (-.f64 (exp.f64 im) (cosh.f64 im))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (cosh.f64 im) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (exp.f64 im) (cosh.f64 im))))))
(/.f64 (-.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (pow.f64 (cosh.f64 im) #s(literal 2 binary64))) (-.f64 (exp.f64 im) (cosh.f64 im)))
(/.f64 (+.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (pow.f64 (cosh.f64 im) #s(literal 3 binary64))) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (exp.f64 im) (cosh.f64 im)))))
(-.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal 2 binary64)) (-.f64 (exp.f64 im) (cosh.f64 im))) (/.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (-.f64 (exp.f64 im) (cosh.f64 im))))
(+.f64 (/.f64 (pow.f64 (exp.f64 im) #s(literal 3 binary64)) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 (exp.f64 im) (cosh.f64 im))))) (/.f64 (pow.f64 (cosh.f64 im) #s(literal 3 binary64)) (fma.f64 (exp.f64 im) (exp.f64 im) (-.f64 (pow.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 (exp.f64 im) (cosh.f64 im))))))
(+.f64 (cosh.f64 im) (exp.f64 im))
(+.f64 (exp.f64 im) (cosh.f64 im))
(/.f64 (neg.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64))) #s(literal -2 binary64))
(/.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 2 binary64))
(cosh.f64 (neg.f64 (neg.f64 im)))
(cosh.f64 (neg.f64 im))
(cosh.f64 im)
(-.f64 (/.f64 (+.f64 (cosh.f64 im) (exp.f64 im)) #s(literal 2 binary64)) (/.f64 (sinh.f64 im) #s(literal 2 binary64)))
(-.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 (neg.f64 (*.f64 #s(literal 2 binary64) (sinh.f64 im))) #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)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) re) #s(literal 1/2 binary64)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 (.f64 #s(literal -1/6 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64))) (.f64 re re) (.f64 (cosh.f64 im) #s(literal 2 binary64)))) re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 (.f64 #s(literal 1/120 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64))) (.f64 re re) (.f64 #s(literal -1/6 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64))))) (.f64 re re) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 (.f64 #s(literal -1/5040 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64))) (.f64 re re) (.f64 #s(literal 1/120 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64))))) (.f64 re re) (.f64 (.f64 #s(literal -1/6 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64))) #s(literal 1/2 binary64))) (.f64 re re) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) re))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) re))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (.f64 (fma.f64 (cosh.f64 im) #s(literal 2 binary64) (.f64 (.f64 #s(literal -1/6 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64))) (*.f64 re re))) re))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (.f64 (fma.f64 (cosh.f64 im) #s(literal 2 binary64) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/120 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64))) (.f64 re re))) (.f64 re re))) re))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (.f64 (fma.f64 (cosh.f64 im) #s(literal 2 binary64) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 (fma.f64 #s(literal 1/120 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 (.f64 #s(literal -1/5040 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64))) (.f64 re re))) (.f64 re re))) (*.f64 re re))) re))
#s(approx (sin re) re)
#s(approx (sin re) (.f64 (fma.f64 (.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64)) re))
#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 (sin re) (.f64 (fma.f64 (-.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)) (*.f64 re re) #s(literal 1 binary64)) re))
#s(approx re re)
#s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re))
#s(approx (* (exp (neg im)) (sin re)) (.f64 (fma.f64 (.f64 (*.f64 re re) (exp.f64 (neg.f64 im))) #s(literal -1/6 binary64) (exp.f64 (neg.f64 im))) re))
#s(approx (* (exp (neg im)) (sin re)) (.f64 (fma.f64 (fma.f64 (.f64 (.f64 re re) (exp.f64 (neg.f64 im))) #s(literal 1/120 binary64) (.f64 (exp.f64 (neg.f64 im)) #s(literal -1/6 binary64))) (*.f64 re re) (exp.f64 (neg.f64 im))) re))
#s(approx (* (exp (neg im)) (sin re)) (.f64 (fma.f64 (fma.f64 (fma.f64 (.f64 (.f64 re re) (exp.f64 (neg.f64 im))) #s(literal -1/5040 binary64) (.f64 #s(literal 1/120 binary64) (exp.f64 (neg.f64 im)))) (.f64 re re) (.f64 (exp.f64 (neg.f64 im)) #s(literal -1/6 binary64))) (*.f64 re re) (exp.f64 (neg.f64 im))) re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) re) #s(literal 1/2 binary64)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) (.f64 re re)) (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/240 binary64) (.f64 re re)) (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 #s(literal -1/12 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64)))) (.f64 re re) (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal -1/10080 binary64) (.f64 re re)) (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 #s(literal 1/240 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64)))) (.f64 re re) (.f64 #s(literal -1/12 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64)))) (.f64 re re) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) re))
#s(approx (* (* re 1/2) (* 2 (cosh im))) (.f64 (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) re) #s(literal 1/2 binary64)))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) re)
#s(approx (* (+ (* -1/6 (* re re)) 1) re) (.f64 (fma.f64 (.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64)) re))
#s(approx (+ (* -1/6 (* re re)) 1) #s(literal 1 binary64))
#s(approx (+ (* -1/6 (* re re)) 1) (fma.f64 (*.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64)))
#s(approx (* re re) (*.f64 re re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) re) #s(literal 1/2 binary64)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) (.f64 re re)) (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/240 binary64) (.f64 re re)) (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 #s(literal -1/12 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64)))) (.f64 re re) (.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal -1/10080 binary64) (.f64 re re)) (.f64 (cosh.f64 im) #s(literal 2 binary64)) (.f64 #s(literal 1/240 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64)))) (.f64 re re) (.f64 #s(literal -1/12 binary64) (.f64 (cosh.f64 im) #s(literal 2 binary64)))) (.f64 re re) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) re))
#s(approx (* 1/2 (sin re)) (*.f64 #s(literal 1/2 binary64) re))
#s(approx (* 1/2 (sin re)) (.f64 (fma.f64 #s(literal -1/12 binary64) (.f64 re re) #s(literal 1/2 binary64)) re))
#s(approx (* 1/2 (sin re)) (.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))
#s(approx (* 1/2 (sin re)) (.f64 (fma.f64 (-.f64 (.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))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (.f64 #s(literal 1/2 binary64) re) (-.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (*.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 1/2 binary64)))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (fma.f64 (.f64 (-.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 1/2 binary64))) (.f64 re re)) #s(literal -1/12 binary64) (.f64 (-.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 1/2 binary64))) #s(literal 1/2 binary64))) re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (fma.f64 (fma.f64 (.f64 (-.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 1/2 binary64))) (.f64 re re)) #s(literal 1/240 binary64) (.f64 (-.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 1/2 binary64))) #s(literal -1/12 binary64))) (.f64 re re) (.f64 (-.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (*.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 1/2 binary64))) #s(literal 1/2 binary64))) re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (fma.f64 (fma.f64 (fma.f64 (.f64 (-.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 1/2 binary64))) (.f64 re re)) #s(literal -1/10080 binary64) (.f64 (-.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 1/2 binary64))) #s(literal 1/240 binary64))) (.f64 re re) (.f64 (-.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 1/2 binary64))) #s(literal -1/12 binary64))) (.f64 re re) (.f64 (-.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 1/2 binary64))) #s(literal 1/2 binary64))) re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (sin.f64 re)))
#s(approx (sin re) (sin.f64 re))
#s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (-.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/6 binary64)) (pow.f64 re #s(literal 3 binary64))))
#s(approx (+ (* -1/6 (* re re)) 1) (.f64 (.f64 re re) #s(literal -1/6 binary64)))
#s(approx (+ (* -1/6 (* re re)) 1) (.f64 (-.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/6 binary64)) (.f64 re re)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (* 1/2 (sin re)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (-.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (*.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 1/2 binary64)))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) (neg.f64 (*.f64 (-.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal -2 binary64))) (pow.f64 re #s(literal 3 binary64)))))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (sin.f64 re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (fma.f64 (.f64 (.f64 #s(literal 0 binary64) (sin.f64 re)) im) #s(literal 1/2 binary64) (sin.f64 re)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (fma.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 (sin.f64 re) im (.f64 #s(literal 0 binary64) (sin.f64 re)))) im (sin.f64 re)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (fma.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 (.f64 (sin.f64 re) #s(literal 0 binary64)) im (sin.f64 re))) im (.f64 (.f64 #s(literal 0 binary64) (sin.f64 re)) #s(literal 1/2 binary64))) im (sin.f64 re)))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (*.f64 #s(literal 2 binary64) (sin.f64 re)))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (fma.f64 (.f64 #s(literal 0 binary64) (sin.f64 re)) im (.f64 #s(literal 2 binary64) (sin.f64 re))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (fma.f64 (fma.f64 #s(literal 0 binary64) (sin.f64 re) (.f64 (sin.f64 re) im)) im (.f64 #s(literal 2 binary64) (sin.f64 re))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (fma.f64 (fma.f64 #s(literal 0 binary64) (sin.f64 re) (.f64 (fma.f64 (.f64 (sin.f64 re) #s(literal 0 binary64)) im (sin.f64 re)) im)) im (*.f64 #s(literal 2 binary64) (sin.f64 re))))
#s(approx (exp im) #s(literal 1 binary64))
#s(approx (exp im) (+.f64 #s(literal 1 binary64) im))
#s(approx (exp im) (fma.f64 (fma.f64 #s(literal 1/2 binary64) im #s(literal 1 binary64)) im #s(literal 1 binary64)))
#s(approx (exp 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)))
#s(approx im im)
#s(approx (* (exp (neg im)) (sin re)) (sin.f64 re))
#s(approx (* (exp (neg im)) (sin re)) (fma.f64 (neg.f64 im) (sin.f64 re) (sin.f64 re)))
#s(approx (* (exp (neg im)) (sin re)) (fma.f64 (fma.f64 (*.f64 #s(literal 1/2 binary64) im) (sin.f64 re) (neg.f64 (sin.f64 re))) im (sin.f64 re)))
#s(approx (* (exp (neg im)) (sin re)) (fma.f64 (fma.f64 (fma.f64 (.f64 (sin.f64 re) im) #s(literal -1/6 binary64) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) im (neg.f64 (sin.f64 re))) im (sin.f64 re)))
#s(approx (exp (neg im)) #s(literal 1 binary64))
#s(approx (exp (neg im)) (fma.f64 #s(literal -1 binary64) im #s(literal 1 binary64)))
#s(approx (exp (neg im)) (fma.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) im) #s(literal 1 binary64)) im #s(literal 1 binary64)))
#s(approx (exp (neg im)) (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)))
#s(approx (neg im) (neg.f64 im))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (sin.f64 re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (fma.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) (sin.f64 re) (sin.f64 re)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (fma.f64 (fma.f64 (.f64 #s(literal 1/24 binary64) (.f64 im im)) (sin.f64 re) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/720 binary64) (.f64 im im)) (sin.f64 re) (.f64 #s(literal 1/24 binary64) (sin.f64 re))) (.f64 im im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (* (* re 1/2) (* 2 (cosh im))) re)
#s(approx (* (* re 1/2) (* 2 (cosh im))) (fma.f64 (.f64 (.f64 im im) re) #s(literal 1/2 binary64) re))
#s(approx (* (* re 1/2) (* 2 (cosh im))) (fma.f64 (fma.f64 (.f64 (.f64 im im) re) #s(literal 1/24 binary64) (.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (* (* re 1/2) (* 2 (cosh im))) (fma.f64 (fma.f64 (fma.f64 (.f64 (.f64 im im) re) #s(literal 1/720 binary64) (.f64 #s(literal 1/24 binary64) re)) (.f64 im im) (.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (sin.f64 re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (fma.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) (sin.f64 re) (sin.f64 re)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (fma.f64 (fma.f64 (.f64 #s(literal 1/24 binary64) (.f64 im im)) (sin.f64 re) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/720 binary64) (.f64 im im)) (sin.f64 re) (.f64 #s(literal 1/24 binary64) (sin.f64 re))) (.f64 im im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) #s(literal 2 binary64))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) (fma.f64 im im #s(literal 2 binary64)))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/12 binary64) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64)))
#s(approx (- (+ (exp im) (cosh im)) (sinh 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 (neg im)) #s(literal 1 binary64))
#s(approx (exp (neg im)) (fma.f64 #s(literal -1 binary64) im #s(literal 1 binary64)))
#s(approx (exp (neg im)) (fma.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) im) #s(literal 1 binary64)) im #s(literal 1 binary64)))
#s(approx (exp (neg im)) (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)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (sin.f64 re))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (fma.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) (sin.f64 re) (sin.f64 re)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (fma.f64 (fma.f64 (.f64 #s(literal 1/24 binary64) (.f64 im im)) (sin.f64 re) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/720 binary64) (.f64 im im)) (sin.f64 re) (.f64 #s(literal 1/24 binary64) (sin.f64 re))) (.f64 im im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) #s(literal 2 binary64))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) (fma.f64 im im #s(literal 2 binary64)))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/12 binary64) #s(literal 1 binary64)) (.f64 im im) #s(literal 2 binary64)))
#s(approx (- (+ (exp im) (cosh im)) (sinh 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 im) (cosh im)) #s(literal 2 binary64))
#s(approx (+ (exp im) (cosh im)) (+.f64 #s(literal 2 binary64) im))
#s(approx (+ (exp im) (cosh im)) (fma.f64 (+.f64 #s(literal 1 binary64) im) im #s(literal 2 binary64)))
#s(approx (+ (exp im) (cosh im)) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/6 binary64) im #s(literal 1 binary64)) im #s(literal 1 binary64)) im #s(literal 2 binary64)))
#s(approx (cosh im) #s(literal 1 binary64))
#s(approx (cosh im) (fma.f64 (*.f64 im im) #s(literal 1/2 binary64) #s(literal 1 binary64)))
#s(approx (cosh im) (fma.f64 (fma.f64 #s(literal 1/24 binary64) (.f64 im im) #s(literal 1/2 binary64)) (.f64 im im) #s(literal 1 binary64)))
#s(approx (cosh im) (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)))
#s(approx (sinh im) im)
#s(approx (sinh im) (.f64 (fma.f64 (.f64 im im) #s(literal 1/6 binary64) #s(literal 1 binary64)) im))
#s(approx (sinh im) (.f64 (fma.f64 (fma.f64 (.f64 im im) #s(literal 1/120 binary64) #s(literal 1/6 binary64)) (*.f64 im im) #s(literal 1 binary64)) im))
#s(approx (sinh im) (.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))
#s(approx (exp im) (exp.f64 im))
#s(approx (exp (neg im)) (exp.f64 (neg.f64 im)))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) (*.f64 (cosh.f64 im) #s(literal 2 binary64)))
#s(approx (exp (neg im)) (exp.f64 (neg.f64 im)))
#s(approx (- (+ (exp im) (cosh im)) (sinh im)) (-.f64 (fma.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (exp.f64 im)) (.f64 (*.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 1/2 binary64))))
#s(approx (+ (exp im) (cosh im)) (fma.f64 (*.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (exp.f64 im)))
#s(approx (cosh im) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))
#s(approx (sinh im) (.f64 (.f64 #s(literal 2 binary64) (sinh.f64 im)) #s(literal 1/2 binary64)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (sin.f64 re)))
#s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))
#s(approx (exp (neg im)) (exp.f64 (neg.f64 im)))
#s(approx (* (* 1/2 (sin re)) (- (+ (exp im) (cosh im)) (sinh im))) (.f64 (.f64 (cosh.f64 im) #s(literal 2 binary64)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))

eval41.0ms (1.3%)

Memory: -6.5MiB live, 92.2MiB allocated; 15ms collecting garbage
Compiler: Compiled 8 376 to 1 432 computations (82.9% saved)

prune8.0ms (0.3%)

Memory

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

Pruning

10 alts after pruning (4 fresh and 6 done)

	Pruned	Kept	Total
New	311	4	315
Fresh	0	0	0
Picked	2	3	5
Done	0	3	3
Total	313	10	323

Accuracy

100.0%

Counts

323 → 10

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	76.5%	(.f64 (fma.f64 (sin.f64 re) (exp.f64 im) #s(approx ( (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re))) #s(literal 1/2 binary64))
✓	100.0%	(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
✓	53.1%	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (-.f64 (+.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 im)))
✓	62.8%	(.f64 (.f64 #s(literal 1/2 binary64) #s(approx (sin re) re)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -1 binary64)) (exp.f64 im)))
✓	62.8%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
✓	52.9%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin.f64 re))
✓	30.0%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (* re 1/2) (* 2 (cosh im))) re))
▶	37.5%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) (.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re)))
▶	10.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) (.f64 #s(approx (+ ( -1/6 (* re re)) 1) (.f64 (.f64 re re) #s(literal -1/6 binary64))) re)))
▶	10.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))))

Compiler

Compiled 200 to 160 computations (20% saved)

series17.0ms (0.5%)

Memory

-6.5MiB live, 40.4MiB allocated; 3ms collecting garbage

Counts

30 → 88

Calls

Call 1

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

Outputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (exp (neg im)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole 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)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 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))))))))))))
#s(approx (sin re) #s(hole binary64 re))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 re))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (* (pow re 3) -1/6) #s(hole binary64 (* -1/6 (pow re 3))))
#s(approx (pow re 3) #s(hole binary64 (pow re 3)))
#s(approx re #s(hole binary64 re))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 1))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 (+ 1 (* -1/6 (pow re 2)))))
#s(approx (* (* re re) -1/6) #s(hole binary64 (* -1/6 (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) #s(hole binary64 re))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (+ (* (* -1/6 re) re) 1) #s(hole binary64 1))
#s(approx (+ (* (* -1/6 re) re) 1) #s(hole binary64 (+ 1 (* -1/6 (pow re 2)))))
#s(approx (* -1/6 re) #s(hole binary64 (* -1/6 re)))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* 1/2 (* re (+ (exp im) (exp (neg im)))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* re (+ (* 1/2 (* (pow re 2) (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im)))))) (* 1/2 (+ (exp im) (exp (neg im))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (+ (* 1/120 (exp im)) (* 1/120 (exp (neg im)))))) (* 1/2 (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im)))))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* 1/2 (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (+ (* -1/5040 (exp im)) (* -1/5040 (exp (neg im)))))) (* 1/2 (+ (* 1/120 (exp im)) (* 1/120 (exp (neg im)))))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (exp (neg im))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp im)) (+ (* -1/6 (exp (neg im))) (* (pow re 2) (+ (* 1/120 (exp im)) (* 1/120 (exp (neg im)))))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp im)) (+ (* -1/6 (exp (neg im))) (* (pow re 2) (+ (* 1/120 (exp im)) (+ (* 1/120 (exp (neg im))) (* (pow re 2) (+ (* -1/5040 (exp im)) (* -1/5040 (exp (neg im))))))))))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (exp (neg im)))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (+ (exp (neg im)) (* -1/6 (* (pow re 2) (exp (neg im))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp (neg im))) (* 1/120 (* (pow re 2) (exp (neg im))))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp (neg im))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (exp (neg im)))) (* 1/120 (exp (neg im)))))))))))
#s(approx (* (exp (neg im)) re) #s(hole binary64 (* re (exp (neg im)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))))
#s(approx (sin re) #s(hole binary64 (sin re)))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* -1/6 (pow re 3))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* (pow re 3) (- (/ 1 (pow re 2)) 1/6))))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 (* -1/6 (pow re 2))))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 (* (pow re 2) (- (/ 1 (pow re 2)) 1/6))))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) #s(hole binary64 (* -1/6 (pow re 3))))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) #s(hole binary64 (* (pow re 3) (- (/ 1 (pow re 2)) 1/6))))
#s(approx (+ (* (* -1/6 re) re) 1) #s(hole binary64 (* -1/6 (pow re 2))))
#s(approx (+ (* (* -1/6 re) re) 1) #s(hole binary64 (* (pow re 2) (- (/ 1 (pow re 2)) 1/6))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* 1/2 (+ (* (exp im) (sin re)) (* (exp (neg im)) (sin re))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* (exp im) (sin re)) (* (exp (neg im)) (sin re)))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* (exp (neg im)) (sin re))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* -1 (* (pow re 3) (- 1/6 (/ 1 (pow re 2)))))))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) #s(hole binary64 (* -1 (* (pow re 3) (- 1/6 (/ 1 (pow re 2)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (sin re)))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (+ (sin re) (* 1/2 (* im (+ (sin re) (* -1 (sin re))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (+ (sin re) (* im (+ (* 1/2 (* im (sin re))) (* 1/2 (+ (sin re) (* -1 (sin re)))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (+ (sin re) (* im (+ (* 1/2 (+ (sin re) (* -1 (sin re)))) (* im (+ (* 1/2 (sin re)) (* 1/2 (* im (+ (* -1/6 (sin re)) (* 1/6 (sin re))))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* 2 (sin re))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* 2 (sin re)) (* im (+ (sin re) (* -1 (sin re)))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* 2 (sin re)) (* im (+ (sin re) (+ (* -1 (sin re)) (* im (sin re))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* 2 (sin re)) (* im (+ (sin re) (+ (* -1 (sin re)) (* im (+ (sin re) (* im (+ (* -1/6 (sin re)) (* 1/6 (sin re))))))))))))
#s(approx (exp im) #s(hole binary64 1))
#s(approx (exp im) #s(hole binary64 (+ 1 im)))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* 1/2 im))))))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))))
#s(approx im #s(hole binary64 im))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (sin re)))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (+ (sin re) (* -1 (* im (sin re))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (+ (sin re) (* im (+ (* -1 (sin re)) (* 1/2 (* im (sin re))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (+ (sin re) (* im (+ (* -1 (sin re)) (* im (+ (* -1/6 (* im (sin re))) (* 1/2 (sin re)))))))))
#s(approx (* (exp (neg im)) re) #s(hole binary64 re))
#s(approx (* (exp (neg im)) re) #s(hole binary64 (+ re (* -1 (* im re)))))
#s(approx (* (exp (neg im)) re) #s(hole binary64 (+ re (* im (+ (* -1 re) (* 1/2 (* im re)))))))
#s(approx (* (exp (neg im)) re) #s(hole binary64 (+ re (* im (+ (* -1 re) (* im (+ (* -1/6 (* im re)) (* 1/2 re))))))))
#s(approx (exp (neg im)) #s(hole binary64 1))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* -1 im))))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* im (- (* 1/2 im) 1)))))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (exp im) #s(hole binary64 (exp im)))
#s(approx (exp (neg im)) #s(hole binary64 (exp (neg im))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* 1/2 (+ (* (exp im) (sin re)) (* (exp (* -1 im)) (sin re))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* (exp im) (sin re)) (* (exp (* -1 im)) (sin re)))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* (exp (* -1 im)) (sin re))))
#s(approx (* (exp (neg im)) re) #s(hole binary64 (* re (exp (* -1 im)))))
#s(approx (exp (neg im)) #s(hole binary64 (exp (* -1 im))))

Calls

6 calls:

Time	Variable		Point	Expression
5.0ms	re	@	inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (* (pow re 3) -1/6) (pow re 3) re 3 -1/6 (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (+ (* -1/6 (* re re)) 1) (* (* re re) -1/6) (* re re) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* (* -1/6 re) re) 1) re) (+ (* (* -1/6 re) re) 1) (* -1/6 re) 1 (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (sin re) (exp im) im (* (exp (neg im)) (sin re)) (* (exp (neg im)) re) (exp (neg im)) (neg im) 1/2)
3.0ms	re	@	-inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (* (pow re 3) -1/6) (pow re 3) re 3 -1/6 (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (+ (* -1/6 (* re re)) 1) (* (* re re) -1/6) (* re re) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* (* -1/6 re) re) 1) re) (+ (* (* -1/6 re) re) 1) (* -1/6 re) 1 (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (sin re) (exp im) im (* (exp (neg im)) (sin re)) (* (exp (neg im)) re) (exp (neg im)) (neg im) 1/2)
2.0ms	re	@	0	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (* (pow re 3) -1/6) (pow re 3) re 3 -1/6 (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (+ (* -1/6 (* re re)) 1) (* (* re re) -1/6) (* re re) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* (* -1/6 re) re) 1) re) (+ (* (* -1/6 re) re) 1) (* -1/6 re) 1 (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (sin re) (exp im) im (* (exp (neg im)) (sin re)) (* (exp (neg im)) re) (exp (neg im)) (neg im) 1/2)
2.0ms	im	@	-inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (* (pow re 3) -1/6) (pow re 3) re 3 -1/6 (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (+ (* -1/6 (* re re)) 1) (* (* re re) -1/6) (* re re) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* (* -1/6 re) re) 1) re) (+ (* (* -1/6 re) re) 1) (* -1/6 re) 1 (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (sin re) (exp im) im (* (exp (neg im)) (sin re)) (* (exp (neg im)) re) (exp (neg im)) (neg im) 1/2)
2.0ms	im	@	inf	((* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (* (pow re 3) -1/6) (pow re 3) re 3 -1/6 (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* -1/6 (* re re)) 1) re) (+ (* -1/6 (* re re)) 1) (* (* re re) -1/6) (* re re) (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin re) (* (+ (* (* -1/6 re) re) 1) re) (+ (* (* -1/6 re) re) 1) (* -1/6 re) 1 (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (sin re) (exp im) im (* (exp (neg im)) (sin re)) (* (exp (neg im)) re) (exp (neg im)) (neg im) 1/2)

rewrite189.0ms (6.1%)

Memory

4.0MiB live, 192.9MiB allocated; 24ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	373	2149
0	390	1815
1	2283	1815
0	8461	1750

Stop Event

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

Counts

118 → 204

Calls

Call 1

Inputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
#s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))
(*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64))
(pow.f64 re #s(literal 3 binary64))
re
#s(literal 3 binary64)
#s(literal -1/6 binary64)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) (.f64 #s(approx (+ ( -1/6 (* re re)) 1) (.f64 (.f64 re re) #s(literal -1/6 binary64))) re)))
#s(approx (sin re) (.f64 #s(approx (+ ( -1/6 (* re re)) 1) (.f64 (.f64 re re) #s(literal -1/6 binary64))) re))
(.f64 #s(approx (+ ( -1/6 (* re re)) 1) (.f64 (.f64 re re) #s(literal -1/6 binary64))) re)
#s(approx (+ (* -1/6 (* re re)) 1) (.f64 (.f64 re re) #s(literal -1/6 binary64)))
(.f64 (.f64 re re) #s(literal -1/6 binary64))
(*.f64 re re)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) (.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re)))
#s(approx (sin re) (.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re))
(.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re)
(fma.f64 (*.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64))
(*.f64 #s(literal -1/6 binary64) re)
#s(literal 1 binary64)
(.f64 (fma.f64 (sin.f64 re) (exp.f64 im) #s(approx ( (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re))) #s(literal 1/2 binary64))
(fma.f64 (sin.f64 re) (exp.f64 im) #s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re)))
(sin.f64 re)
(exp.f64 im)
im
#s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re))
(*.f64 (exp.f64 (neg.f64 im)) re)
(exp.f64 (neg.f64 im))
(neg.f64 im)
#s(literal 1/2 binary64)
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* re (+ (exp im) (exp (neg im)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* re (+ (* -1/12 (* (pow re 2) (+ (exp im) (exp (neg im))))) (* 1/2 (+ (exp im) (exp (neg im))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole 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)))))))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 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))))))))))))
#s(approx (sin re) #s(hole binary64 re))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* 1/120 (pow re 2)) 1/6))))))
#s(approx (sin re) #s(hole binary64 (* re (+ 1 (* (pow re 2) (- (* (pow re 2) (+ 1/120 (* -1/5040 (pow re 2)))) 1/6))))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 re))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (* (pow re 3) -1/6) #s(hole binary64 (* -1/6 (pow re 3))))
#s(approx (pow re 3) #s(hole binary64 (pow re 3)))
#s(approx re #s(hole binary64 re))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 1))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 (+ 1 (* -1/6 (pow re 2)))))
#s(approx (* (* re re) -1/6) #s(hole binary64 (* -1/6 (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) #s(hole binary64 re))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) #s(hole binary64 (* re (+ 1 (* -1/6 (pow re 2))))))
#s(approx (+ (* (* -1/6 re) re) 1) #s(hole binary64 1))
#s(approx (+ (* (* -1/6 re) re) 1) #s(hole binary64 (+ 1 (* -1/6 (pow re 2)))))
#s(approx (* -1/6 re) #s(hole binary64 (* -1/6 re)))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* 1/2 (* re (+ (exp im) (exp (neg im)))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* re (+ (* 1/2 (* (pow re 2) (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im)))))) (* 1/2 (+ (exp im) (exp (neg im))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (+ (* 1/120 (exp im)) (* 1/120 (exp (neg im)))))) (* 1/2 (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im)))))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* re (+ (* 1/2 (+ (exp im) (exp (neg im)))) (* (pow re 2) (+ (* 1/2 (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im))))) (* (pow re 2) (+ (* 1/2 (* (pow re 2) (+ (* -1/5040 (exp im)) (* -1/5040 (exp (neg im)))))) (* 1/2 (+ (* 1/120 (exp im)) (* 1/120 (exp (neg im)))))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (exp (neg im))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp im)) (* -1/6 (exp (neg im))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp im)) (+ (* -1/6 (exp (neg im))) (* (pow re 2) (+ (* 1/120 (exp im)) (* 1/120 (exp (neg im)))))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* re (+ (exp im) (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp im)) (+ (* -1/6 (exp (neg im))) (* (pow re 2) (+ (* 1/120 (exp im)) (+ (* 1/120 (exp (neg im))) (* (pow re 2) (+ (* -1/5040 (exp im)) (* -1/5040 (exp (neg im))))))))))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (exp (neg im)))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (+ (exp (neg im)) (* -1/6 (* (pow re 2) (exp (neg im))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp (neg im))) (* 1/120 (* (pow re 2) (exp (neg im))))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* re (+ (exp (neg im)) (* (pow re 2) (+ (* -1/6 (exp (neg im))) (* (pow re 2) (+ (* -1/5040 (* (pow re 2) (exp (neg im)))) (* 1/120 (exp (neg im)))))))))))
#s(approx (* (exp (neg im)) re) #s(hole binary64 (* re (exp (neg im)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (neg im)))))))
#s(approx (sin re) #s(hole binary64 (sin re)))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* -1/6 (pow re 3))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* (pow re 3) (- (/ 1 (pow re 2)) 1/6))))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 (* -1/6 (pow re 2))))
#s(approx (+ (* -1/6 (* re re)) 1) #s(hole binary64 (* (pow re 2) (- (/ 1 (pow re 2)) 1/6))))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) #s(hole binary64 (* -1/6 (pow re 3))))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) #s(hole binary64 (* (pow re 3) (- (/ 1 (pow re 2)) 1/6))))
#s(approx (+ (* (* -1/6 re) re) 1) #s(hole binary64 (* -1/6 (pow re 2))))
#s(approx (+ (* (* -1/6 re) re) 1) #s(hole binary64 (* (pow re 2) (- (/ 1 (pow re 2)) 1/6))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* 1/2 (+ (* (exp im) (sin re)) (* (exp (neg im)) (sin re))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* (exp im) (sin re)) (* (exp (neg im)) (sin re)))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* (exp (neg im)) (sin re))))
#s(approx (* (+ (* -1/6 (* re re)) 1) re) #s(hole binary64 (* -1 (* (pow re 3) (- 1/6 (/ 1 (pow re 2)))))))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) #s(hole binary64 (* -1 (* (pow re 3) (- 1/6 (/ 1 (pow re 2)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (sin re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* 1/2 (* (pow im 2) (sin re))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/24 (* (pow im 2) (sin re))) (* 1/2 (sin re)))))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (+ (sin re) (* (pow im 2) (+ (* 1/2 (sin re)) (* (pow im 2) (+ (* 1/720 (* (pow im 2) (sin re))) (* 1/24 (sin re)))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (sin re)))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (+ (sin re) (* 1/2 (* im (+ (sin re) (* -1 (sin re))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (+ (sin re) (* im (+ (* 1/2 (* im (sin re))) (* 1/2 (+ (sin re) (* -1 (sin re)))))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (+ (sin re) (* im (+ (* 1/2 (+ (sin re) (* -1 (sin re)))) (* im (+ (* 1/2 (sin re)) (* 1/2 (* im (+ (* -1/6 (sin re)) (* 1/6 (sin re))))))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (* 2 (sin re))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* 2 (sin re)) (* im (+ (sin re) (* -1 (sin re)))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* 2 (sin re)) (* im (+ (sin re) (+ (* -1 (sin re)) (* im (sin re))))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* 2 (sin re)) (* im (+ (sin re) (+ (* -1 (sin re)) (* im (+ (sin re) (* im (+ (* -1/6 (sin re)) (* 1/6 (sin re))))))))))))
#s(approx (exp im) #s(hole binary64 1))
#s(approx (exp im) #s(hole binary64 (+ 1 im)))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* 1/2 im))))))
#s(approx (exp im) #s(hole binary64 (+ 1 (* im (+ 1 (* im (+ 1/2 (* 1/6 im))))))))
#s(approx im #s(hole binary64 im))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (sin re)))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (+ (sin re) (* -1 (* im (sin re))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (+ (sin re) (* im (+ (* -1 (sin re)) (* 1/2 (* im (sin re))))))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (+ (sin re) (* im (+ (* -1 (sin re)) (* im (+ (* -1/6 (* im (sin re))) (* 1/2 (sin re)))))))))
#s(approx (* (exp (neg im)) re) #s(hole binary64 re))
#s(approx (* (exp (neg im)) re) #s(hole binary64 (+ re (* -1 (* im re)))))
#s(approx (* (exp (neg im)) re) #s(hole binary64 (+ re (* im (+ (* -1 re) (* 1/2 (* im re)))))))
#s(approx (* (exp (neg im)) re) #s(hole binary64 (+ re (* im (+ (* -1 re) (* im (+ (* -1/6 (* im re)) (* 1/2 re))))))))
#s(approx (exp (neg im)) #s(hole binary64 1))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* -1 im))))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* im (- (* 1/2 im) 1)))))
#s(approx (exp (neg im)) #s(hole binary64 (+ 1 (* im (- (* im (+ 1/2 (* -1/6 im))) 1)))))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (exp im) #s(hole binary64 (exp im)))
#s(approx (exp (neg im)) #s(hole binary64 (exp (neg im))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(hole binary64 (* 1/2 (* (sin re) (+ (exp im) (exp (* -1 im)))))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(hole binary64 (* 1/2 (+ (* (exp im) (sin re)) (* (exp (* -1 im)) (sin re))))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) #s(hole binary64 (+ (* (exp im) (sin re)) (* (exp (* -1 im)) (sin re)))))
#s(approx (* (exp (neg im)) (sin re)) #s(hole binary64 (* (exp (* -1 im)) (sin re))))
#s(approx (* (exp (neg im)) re) #s(hole binary64 (* re (exp (* -1 im)))))
#s(approx (exp (neg im)) #s(hole binary64 (exp (* -1 im))))

Outputs
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(approx (sin re) #s(approx (* (+ (* (* -1/6 re) re) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
#s(approx (sin re) #s(approx (* (+ (* (* -1/6 re) re) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64))))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))
(*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64))
(*.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 3 binary64)))
(*.f64 (neg.f64 (pow.f64 re #s(literal 3/2 binary64))) (neg.f64 (pow.f64 re #s(literal 3/2 binary64))))
(*.f64 (fabs.f64 (pow.f64 re #s(literal 3/2 binary64))) (fabs.f64 (pow.f64 re #s(literal 3/2 binary64))))
(*.f64 (pow.f64 re #s(literal 3/2 binary64)) (pow.f64 re #s(literal 3/2 binary64)))
(.f64 (.f64 re re) re)
(.f64 re (.f64 re re))
(pow.f64 (exp.f64 (log.f64 re)) #s(literal 3 binary64))
(pow.f64 (pow.f64 re #s(literal 3/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 3/2 binary64))
(pow.f64 re #s(literal 3 binary64))
(exp.f64 (*.f64 (log.f64 re) #s(literal 3 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 re) #s(literal 3 binary64))) (sinh.f64 (.f64 (log.f64 re) #s(literal 3 binary64))))
re
#s(literal 3 binary64)
#s(literal -1/6 binary64)
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(approx (sin re) (.f64 #s(approx (+ ( (* -1/6 re) re) 1) (.f64 (.f64 #s(literal -1/6 binary64) re) re)) re)))
#s(approx (sin re) (.f64 #s(approx (+ ( (* -1/6 re) re) 1) (.f64 (.f64 #s(literal -1/6 binary64) re) re)) re))
(.f64 #s(approx (+ ( (* -1/6 re) re) 1) (.f64 (.f64 #s(literal -1/6 binary64) re) re)) re)
(.f64 re #s(approx (+ ( (* -1/6 re) re) 1) (.f64 (.f64 #s(literal -1/6 binary64) re) re)))
#s(approx (+ (* (* -1/6 re) re) 1) (.f64 (.f64 #s(literal -1/6 binary64) re) re))
(.f64 (.f64 #s(literal -1/6 binary64) re) re)
(.f64 (.f64 re re) #s(literal -1/6 binary64))
(.f64 #s(literal -1/6 binary64) (.f64 re re))
(.f64 re (.f64 #s(literal -1/6 binary64) re))
(*.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)))
(*.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)))
(*.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)))
(*.f64 (exp.f64 (log.f64 re)) (exp.f64 (log.f64 re)))
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 re re)
(pow.f64 (exp.f64 (log.f64 re)) #s(literal 2 binary64))
(pow.f64 (fabs.f64 re) #s(literal 2 binary64))
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(fabs.f64 (*.f64 re re))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) #s(approx (sin re) (.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re)))
#s(approx (sin re) (.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re))
(.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re)
(.f64 re (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)))
(/.f64 (+.f64 (pow.f64 (.f64 #s(literal 1 binary64) re) #s(literal 3 binary64)) (pow.f64 (.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) re) #s(literal 3 binary64))) (fma.f64 (.f64 #s(literal 1 binary64) re) (.f64 #s(literal 1 binary64) re) (-.f64 (.f64 (.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) re) (.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) re)) (.f64 (.f64 #s(literal 1 binary64) re) (.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) re)))))
(/.f64 (+.f64 (pow.f64 (.f64 re #s(literal 1 binary64)) #s(literal 3 binary64)) (pow.f64 (.f64 re (.f64 (.f64 #s(literal -1/6 binary64) re) re)) #s(literal 3 binary64))) (fma.f64 (.f64 re #s(literal 1 binary64)) (.f64 re #s(literal 1 binary64)) (-.f64 (.f64 (.f64 re (.f64 (.f64 #s(literal -1/6 binary64) re) re)) (.f64 re (.f64 (.f64 #s(literal -1/6 binary64) re) re))) (.f64 (.f64 re #s(literal 1 binary64)) (.f64 re (.f64 (.f64 #s(literal -1/6 binary64) re) re))))))
(fma.f64 #s(literal 1 binary64) re (.f64 (.f64 (*.f64 #s(literal -1/6 binary64) re) re) re))
(fma.f64 re #s(literal 1 binary64) (.f64 re (.f64 (*.f64 #s(literal -1/6 binary64) re) re)))
(+.f64 (.f64 #s(literal 1 binary64) re) (.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) re))
(+.f64 (.f64 re #s(literal 1 binary64)) (.f64 re (.f64 (.f64 #s(literal -1/6 binary64) re) re)))
(/.f64 (neg.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64)))) (neg.f64 (-.f64 #s(literal 1 binary64) (.f64 (.f64 #s(literal -1/6 binary64) re) re))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64)) #s(literal 1 binary64))) (neg.f64 (-.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 1 binary64))))
(/.f64 (neg.f64 (+.f64 #s(literal 1 binary64) (.f64 #s(literal -1/216 binary64) (pow.f64 (.f64 re re) #s(literal 3 binary64))))) (neg.f64 (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (.f64 (*.f64 #s(literal -1/6 binary64) re) re))))))
(/.f64 (neg.f64 (fma.f64 #s(literal -1/216 binary64) (pow.f64 (.f64 re re) #s(literal 3 binary64)) #s(literal 1 binary64))) (neg.f64 (+.f64 (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 1 binary64))))))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64))) (-.f64 #s(literal 1 binary64) (.f64 (.f64 #s(literal -1/6 binary64) re) re)))
(/.f64 (-.f64 (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64)) #s(literal 1 binary64)) (-.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 1 binary64)))
(/.f64 (+.f64 #s(literal 1 binary64) (.f64 #s(literal -1/216 binary64) (pow.f64 (.f64 re re) #s(literal 3 binary64)))) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (.f64 (*.f64 #s(literal -1/6 binary64) re) re)))))
(/.f64 (fma.f64 #s(literal -1/216 binary64) (pow.f64 (.f64 re re) #s(literal 3 binary64)) #s(literal 1 binary64)) (+.f64 (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 1 binary64)))))
(fma.f64 (*.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64))
(fma.f64 (*.f64 re re) #s(literal -1/6 binary64) #s(literal 1 binary64))
(fma.f64 #s(literal -1/6 binary64) (*.f64 re re) #s(literal 1 binary64))
(fma.f64 re (*.f64 #s(literal -1/6 binary64) re) #s(literal 1 binary64))
(-.f64 (/.f64 #s(literal 1 binary64) (-.f64 #s(literal 1 binary64) (.f64 (.f64 #s(literal -1/6 binary64) re) re))) (/.f64 (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (.f64 #s(literal -1/6 binary64) re) re))))
(-.f64 (/.f64 (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64)) (-.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 1 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 1 binary64))))
(-.f64 #s(literal 1 binary64) (.f64 #s(literal 1/6 binary64) (.f64 re re)))
(+.f64 (/.f64 #s(literal 1 binary64) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (.f64 (.f64 #s(literal -1/6 binary64) re) re))))) (/.f64 (.f64 #s(literal -1/216 binary64) (pow.f64 (.f64 re re) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (.f64 (.f64 #s(literal -1/6 binary64) re) re))))))
(+.f64 (/.f64 (.f64 #s(literal -1/216 binary64) (pow.f64 (.f64 re re) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 1 binary64))))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 1 binary64))))))
(+.f64 #s(literal 1 binary64) (.f64 (.f64 #s(literal -1/6 binary64) re) re))
(+.f64 (.f64 (.f64 #s(literal -1/6 binary64) re) re) #s(literal 1 binary64))
(*.f64 #s(literal -1/6 binary64) re)
(*.f64 re #s(literal -1/6 binary64))
#s(literal 1 binary64)
(.f64 (fma.f64 (exp.f64 im) (sin.f64 re) #s(approx ( (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re))) #s(literal 1/2 binary64))
(.f64 #s(literal 1/2 binary64) (fma.f64 (exp.f64 im) (sin.f64 re) #s(approx ( (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re))))
(/.f64 (+.f64 (pow.f64 #s(approx (* (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) #s(literal 3 binary64)) (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64))) (+.f64 (pow.f64 #s(approx (* (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (.f64 #s(approx ( (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) (.f64 (exp.f64 im) (sin.f64 re))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (pow.f64 #s(approx ( (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re)))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64)) (pow.f64 #s(approx ( (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 #s(approx (* (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) #s(literal 2 binary64)) (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(approx ( (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re)))))))
(/.f64 (-.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (pow.f64 #s(approx ( (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) #s(literal 2 binary64))) (-.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re))))
(/.f64 (+.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64)) (pow.f64 #s(approx ( (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 #s(approx (* (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) #s(literal 2 binary64)) (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(approx ( (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re))))))
(fma.f64 (exp.f64 im) (sin.f64 re) #s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re)))
(fma.f64 (sin.f64 re) (exp.f64 im) #s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re)))
(-.f64 (/.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(approx (* (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)))) (/.f64 (pow.f64 #s(approx ( (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) #s(literal 2 binary64)) (-.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re)))))
(+.f64 (/.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 #s(approx (* (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) #s(literal 2 binary64)) (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(approx ( (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)))))) (/.f64 (pow.f64 #s(approx ( (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) #s(literal 3 binary64)) (+.f64 (pow.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(literal 2 binary64)) (-.f64 (pow.f64 #s(approx (* (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) #s(literal 2 binary64)) (.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(approx ( (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re)))))))
(+.f64 (.f64 (exp.f64 im) (sin.f64 re)) #s(approx ( (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re)))
(+.f64 #s(approx (* (exp (neg im)) (sin re)) (.f64 (exp.f64 (neg.f64 im)) re)) (.f64 (exp.f64 im) (sin.f64 re)))
(sin.f64 re)
(/.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 (cosh.f64 im) (sinh.f64 im))
im
#s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re))
(*.f64 (exp.f64 (neg.f64 im)) re)
(*.f64 re (exp.f64 (neg.f64 im)))
(pow.f64 (exp.f64 #s(literal -1 binary64)) im)
(pow.f64 (exp.f64 im) #s(literal -1 binary64))
(/.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 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) im))
(exp.f64 (neg.f64 im))
(+.f64 (cosh.f64 im) (sinh.f64 (neg.f64 im)))
(*.f64 #s(literal -1 binary64) im)
(*.f64 im #s(literal -1 binary64))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im))) (neg.f64 (+.f64 #s(literal 0 binary64) im)))
(/.f64 (neg.f64 (-.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 3 binary64)))) (neg.f64 (+.f64 #s(literal 0 binary64) (fma.f64 im im (*.f64 #s(literal 0 binary64) im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 im im)) (+.f64 #s(literal 0 binary64) im))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 im #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 im im (*.f64 #s(literal 0 binary64) im))))
(neg.f64 im)
(-.f64 (/.f64 #s(literal 0 binary64) (+.f64 #s(literal 0 binary64) im)) (/.f64 (*.f64 im im) (+.f64 #s(literal 0 binary64) im)))
(-.f64 (/.f64 #s(literal 0 binary64) (+.f64 #s(literal 0 binary64) (fma.f64 im im (.f64 #s(literal 0 binary64) im)))) (/.f64 (pow.f64 im #s(literal 3 binary64)) (+.f64 #s(literal 0 binary64) (fma.f64 im im (.f64 #s(literal 0 binary64) im)))))
(-.f64 #s(literal 0 binary64) im)
#s(literal 1/2 binary64)
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (.f64 (fma.f64 (.f64 #s(literal -1/12 binary64) (.f64 re re)) (.f64 #s(literal 2 binary64) (cosh.f64 im)) (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64))) re))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/240 binary64) (.f64 re re)) (.f64 #s(literal 2 binary64) (cosh.f64 im)) (.f64 #s(literal -1/12 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im)))) (.f64 re re) (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64))) re))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (.f64 (fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal -1/10080 binary64) (.f64 re re)) (.f64 #s(literal 2 binary64) (cosh.f64 im)) (.f64 #s(literal 1/240 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im)))) (.f64 re re) (.f64 #s(literal -1/12 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im)))) (.f64 re re) (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64))) re))
#s(approx (sin re) re)
#s(approx (sin re) (.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re))
#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 (sin re) (.f64 (fma.f64 (-.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)) (*.f64 re re) #s(literal 1 binary64)) re))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) re)
#s(approx (* (+ (* (* -1/6 re) re) 1) re) (.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re))
#s(approx (* (pow re 3) -1/6) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))
#s(approx (pow re 3) (pow.f64 re #s(literal 3 binary64)))
#s(approx re re)
#s(approx (+ (* (* -1/6 re) re) 1) #s(literal 1 binary64))
#s(approx (+ (* (* -1/6 re) re) 1) (fma.f64 (*.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)))
#s(approx (* (* re re) -1/6) (.f64 (.f64 #s(literal -1/6 binary64) re) re))
#s(approx (* re re) (*.f64 re re))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) re)
#s(approx (* (+ (* (* -1/6 re) re) 1) re) (.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re))
#s(approx (+ (* (* -1/6 re) re) 1) #s(literal 1 binary64))
#s(approx (+ (* (* -1/6 re) re) 1) (fma.f64 (*.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)))
#s(approx (* -1/6 re) (*.f64 #s(literal -1/6 binary64) re))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 (.f64 #s(literal -1/6 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im))) (.f64 re re) (.f64 #s(literal 2 binary64) (cosh.f64 im)))) re))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 (.f64 #s(literal 1/120 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im))) (.f64 re re) (.f64 #s(literal -1/6 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im))))) (.f64 re re) (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64))) re))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 (.f64 #s(literal -1/5040 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im))) (.f64 re re) (.f64 #s(literal 1/120 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im))))) (.f64 re re) (.f64 (.f64 #s(literal -1/6 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im))) #s(literal 1/2 binary64))) (.f64 re re) (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) #s(literal 1/2 binary64))) re))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) re))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (.f64 (fma.f64 #s(literal 2 binary64) (cosh.f64 im) (.f64 (.f64 #s(literal -1/6 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im))) (*.f64 re re))) re))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (.f64 (fma.f64 #s(literal 2 binary64) (cosh.f64 im) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im)) (.f64 (.f64 #s(literal 1/120 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im))) (.f64 re re))) (.f64 re re))) re))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (.f64 (fma.f64 #s(literal 2 binary64) (cosh.f64 im) (.f64 (fma.f64 #s(literal -1/6 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im)) (.f64 (fma.f64 #s(literal 1/120 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im)) (.f64 (.f64 #s(literal -1/5040 binary64) (.f64 #s(literal 2 binary64) (cosh.f64 im))) (.f64 re re))) (.f64 re re))) (*.f64 re re))) re))
#s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re))
#s(approx (* (exp (neg im)) (sin re)) (.f64 (fma.f64 (.f64 (*.f64 re re) (exp.f64 (neg.f64 im))) #s(literal -1/6 binary64) (exp.f64 (neg.f64 im))) re))
#s(approx (* (exp (neg im)) (sin re)) (.f64 (fma.f64 (fma.f64 (.f64 (.f64 re re) (exp.f64 (neg.f64 im))) #s(literal 1/120 binary64) (.f64 (exp.f64 (neg.f64 im)) #s(literal -1/6 binary64))) (*.f64 re re) (exp.f64 (neg.f64 im))) re))
#s(approx (* (exp (neg im)) (sin re)) (.f64 (fma.f64 (fma.f64 (fma.f64 (.f64 (.f64 re re) (exp.f64 (neg.f64 im))) #s(literal -1/5040 binary64) (.f64 #s(literal 1/120 binary64) (exp.f64 (neg.f64 im)))) (.f64 re re) (.f64 (exp.f64 (neg.f64 im)) #s(literal -1/6 binary64))) (*.f64 re re) (exp.f64 (neg.f64 im))) re))
#s(approx (* (exp (neg im)) re) (*.f64 (exp.f64 (neg.f64 im)) re))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (sin re) (sin.f64 re))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) (*.f64 (-.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/6 binary64)) (pow.f64 re #s(literal 3 binary64))))
#s(approx (+ (* (* -1/6 re) re) 1) (.f64 (.f64 #s(literal -1/6 binary64) re) re))
#s(approx (+ (* (* -1/6 re) re) 1) (.f64 (-.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/6 binary64)) (.f64 re re)))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) (*.f64 (-.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/6 binary64)) (pow.f64 re #s(literal 3 binary64))))
#s(approx (+ (* (* -1/6 re) re) 1) (.f64 (.f64 #s(literal -1/6 binary64) re) re))
#s(approx (+ (* (* -1/6 re) re) 1) (.f64 (-.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/6 binary64)) (.f64 re re)))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)))
#s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) (*.f64 (pow.f64 (neg.f64 re) #s(literal 3 binary64)) (-.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal -2 binary64)))))
#s(approx (* (+ (* (* -1/6 re) re) 1) re) (*.f64 (pow.f64 (neg.f64 re) #s(literal 3 binary64)) (-.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal -2 binary64)))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (sin.f64 re))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (sin.f64 re) (sin.f64 re)))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (fma.f64 (fma.f64 (.f64 #s(literal 1/24 binary64) (.f64 im im)) (sin.f64 re) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/720 binary64) (.f64 im im)) (sin.f64 re) (.f64 #s(literal 1/24 binary64) (sin.f64 re))) (.f64 im im) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) (.f64 im im) (sin.f64 re)))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (sin.f64 re))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (fma.f64 (.f64 (.f64 #s(literal 0 binary64) (sin.f64 re)) im) #s(literal 1/2 binary64) (sin.f64 re)))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (fma.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 im (sin.f64 re) (.f64 #s(literal 0 binary64) (sin.f64 re)))) im (sin.f64 re)))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (fma.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 (.f64 (sin.f64 re) #s(literal 0 binary64)) im (sin.f64 re))) im (.f64 (.f64 #s(literal 0 binary64) (sin.f64 re)) #s(literal 1/2 binary64))) im (sin.f64 re)))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (*.f64 #s(literal 2 binary64) (sin.f64 re)))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (fma.f64 (.f64 #s(literal 0 binary64) (sin.f64 re)) im (.f64 #s(literal 2 binary64) (sin.f64 re))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (fma.f64 (fma.f64 #s(literal 0 binary64) (sin.f64 re) (.f64 im (sin.f64 re))) im (.f64 #s(literal 2 binary64) (sin.f64 re))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (fma.f64 (fma.f64 #s(literal 0 binary64) (sin.f64 re) (.f64 (fma.f64 (.f64 (sin.f64 re) #s(literal 0 binary64)) im (sin.f64 re)) im)) im (*.f64 #s(literal 2 binary64) (sin.f64 re))))
#s(approx (exp im) #s(literal 1 binary64))
#s(approx (exp im) (+.f64 #s(literal 1 binary64) im))
#s(approx (exp im) (fma.f64 (fma.f64 im #s(literal 1/2 binary64) #s(literal 1 binary64)) im #s(literal 1 binary64)))
#s(approx (exp 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)))
#s(approx im im)
#s(approx (* (exp (neg im)) (sin re)) (sin.f64 re))
#s(approx (* (exp (neg im)) (sin re)) (fma.f64 (neg.f64 im) (sin.f64 re) (sin.f64 re)))
#s(approx (* (exp (neg im)) (sin re)) (fma.f64 (fma.f64 (*.f64 im #s(literal 1/2 binary64)) (sin.f64 re) (neg.f64 (sin.f64 re))) im (sin.f64 re)))
#s(approx (* (exp (neg im)) (sin re)) (fma.f64 (fma.f64 (fma.f64 (.f64 im (sin.f64 re)) #s(literal -1/6 binary64) (.f64 (sin.f64 re) #s(literal 1/2 binary64))) im (neg.f64 (sin.f64 re))) im (sin.f64 re)))
#s(approx (* (exp (neg im)) re) re)
#s(approx (* (exp (neg im)) re) (fma.f64 (neg.f64 im) re re))
#s(approx (* (exp (neg im)) re) (fma.f64 (fma.f64 (*.f64 im re) #s(literal 1/2 binary64) (neg.f64 re)) im re))
#s(approx (* (exp (neg im)) re) (fma.f64 (fma.f64 (fma.f64 (.f64 im re) #s(literal -1/6 binary64) (.f64 re #s(literal 1/2 binary64))) im (neg.f64 re)) im re))
#s(approx (exp (neg im)) #s(literal 1 binary64))
#s(approx (exp (neg im)) (fma.f64 #s(literal -1 binary64) im #s(literal 1 binary64)))
#s(approx (exp (neg im)) (fma.f64 (-.f64 (*.f64 im #s(literal 1/2 binary64)) #s(literal 1 binary64)) im #s(literal 1 binary64)))
#s(approx (exp (neg im)) (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)))
#s(approx (neg im) (neg.f64 im))
#s(approx (exp im) (exp.f64 im))
#s(approx (exp (neg im)) (exp.f64 (neg.f64 im)))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (* (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) 1/2) (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (*.f64 (sin.f64 re) #s(literal 1/2 binary64))))
#s(approx (+ (* (sin re) (exp im)) (* (exp (neg im)) (sin re))) (.f64 (.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)))
#s(approx (* (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) (sin.f64 re)))
#s(approx (* (exp (neg im)) re) (*.f64 (exp.f64 (neg.f64 im)) re))
#s(approx (exp (neg im)) (exp.f64 (neg.f64 im)))

eval37.0ms (1.2%)

Memory: -16.9MiB live, 29.5MiB allocated; 3ms collecting garbage
Compiler: Compiled 5 489 to 949 computations (82.7% saved)

prune11.0ms (0.4%)

Memory

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

Pruning

14 alts after pruning (5 fresh and 9 done)

	Pruned	Kept	Total
New	165	5	170
Fresh	0	0	0
Picked	1	3	4
Done	0	6	6
Total	166	14	180

Accuracy

100.0%

Counts

180 → 14

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	76.5%	(.f64 (fma.f64 (sin.f64 re) (exp.f64 im) #s(approx ( (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re))) #s(literal 1/2 binary64))
	75.6%	(.f64 (fma.f64 (sin.f64 re) (exp.f64 im) #s(approx ( (exp (neg im)) (sin re)) #s(approx (* (exp (neg im)) re) re))) #s(literal 1/2 binary64))
✓	100.0%	(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
✓	53.1%	(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (-.f64 (+.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 im)))
✓	62.8%	(.f64 (.f64 #s(literal 1/2 binary64) #s(approx (sin re) re)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -1 binary64)) (exp.f64 im)))
✓	62.8%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
✓	52.9%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin.f64 re))
✓	30.0%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (* re 1/2) (* 2 (cosh im))) re))
✓	10.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) (.f64 #s(approx (+ ( -1/6 (* re re)) 1) (.f64 (.f64 re re) #s(literal -1/6 binary64))) re)))
	10.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 (pow.f64 re #s(literal 3/2 binary64)) #s(literal 2 binary64)) #s(literal -1/6 binary64)))))
	10.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (.f64 (pow.f64 (.f64 re re) #s(literal 3/2 binary64)) #s(literal -1/6 binary64)))))
	10.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 (exp.f64 (log.f64 re)) #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
✓	10.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
	10.4%	#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (.f64 (exp.f64 (.f64 (log.f64 re) #s(literal 3 binary64))) #s(literal -1/6 binary64)))))

Compiler

Compiled 758 to 380 computations (49.9% saved)

regimes56.0ms (1.8%)

Memory

-29.8MiB live, 80.7MiB allocated; 13ms collecting garbage

Counts

20 → 1

Calls

Call 1

Inputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (* re 1/2) (* 2 (cosh im))) re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin.f64 re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (.f64 (exp.f64 (.f64 (log.f64 re) #s(literal 3 binary64))) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 (exp.f64 (log.f64 re)) #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (.f64 (pow.f64 (.f64 re re) #s(literal 3/2 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 (pow.f64 re #s(literal 3/2 binary64)) #s(literal 2 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) (.f64 #s(approx (+ ( -1/6 (* re re)) 1) (.f64 (.f64 re re) #s(literal -1/6 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #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 (sin re) (.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
(.f64 (fma.f64 (sin.f64 re) (exp.f64 im) #s(approx ( (exp (neg im)) (sin re)) #s(approx (* (exp (neg im)) re) re))) #s(literal 1/2 binary64))
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
(.f64 (.f64 #s(literal 1/2 binary64) #s(approx (sin re) re)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -1 binary64)) (exp.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 (pow.f64 (exp.f64 im) #s(literal -1 binary64)) (exp.f64 im)))
(.f64 (fma.f64 (sin.f64 re) (exp.f64 im) #s(approx ( (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re))) #s(literal 1/2 binary64))
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (-.f64 (+.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 im)))
(.f64 (fma.f64 (sin.f64 re) (exp.f64 im) (.f64 (exp.f64 (neg.f64 im)) (sin.f64 re))) #s(literal 1/2 binary64))
(fma.f64 (.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 im) (.f64 (*.f64 (sin.f64 re) #s(literal 1/2 binary64)) (exp.f64 (neg.f64 im))))

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

Calls

6 calls:

18.0ms	(sin.f64 re)
15.0ms	re
6.0ms	im
6.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
5.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)

regimes56.0ms (1.8%)

Memory

18.7MiB live, 66.1MiB allocated; 2ms collecting garbage

Counts

18 → 1

Calls

Call 1

Inputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (* re 1/2) (* 2 (cosh im))) re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin.f64 re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (.f64 (exp.f64 (.f64 (log.f64 re) #s(literal 3 binary64))) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 (exp.f64 (log.f64 re)) #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (.f64 (pow.f64 (.f64 re re) #s(literal 3/2 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 (pow.f64 re #s(literal 3/2 binary64)) #s(literal 2 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) (.f64 #s(approx (+ ( -1/6 (* re re)) 1) (.f64 (.f64 re re) #s(literal -1/6 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #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 (sin re) (.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
(.f64 (fma.f64 (sin.f64 re) (exp.f64 im) #s(approx ( (exp (neg im)) (sin re)) #s(approx (* (exp (neg im)) re) re))) #s(literal 1/2 binary64))
(.f64 (.f64 (*.f64 #s(literal 2 binary64) (cosh.f64 im)) (sin.f64 re)) #s(literal 1/2 binary64))
(.f64 (.f64 #s(literal 1/2 binary64) #s(approx (sin re) re)) (+.f64 (pow.f64 (exp.f64 im) #s(literal -1 binary64)) (exp.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 (pow.f64 (exp.f64 im) #s(literal -1 binary64)) (exp.f64 im)))
(.f64 (fma.f64 (sin.f64 re) (exp.f64 im) #s(approx ( (exp (neg im)) (sin re)) (*.f64 (exp.f64 (neg.f64 im)) re))) #s(literal 1/2 binary64))
(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (-.f64 (+.f64 (exp.f64 im) (cosh.f64 im)) (sinh.f64 im)))

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

Calls

6 calls:

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

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)

regimes30.0ms (1%)

Memory

-1.9MiB live, 45.3MiB allocated; 2ms collecting garbage

Counts

12 → 2

Calls

Call 1

Inputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (* re 1/2) (* 2 (cosh im))) re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin.f64 re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (.f64 (exp.f64 (.f64 (log.f64 re) #s(literal 3 binary64))) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 (exp.f64 (log.f64 re)) #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (.f64 (pow.f64 (.f64 re re) #s(literal 3/2 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 (pow.f64 re #s(literal 3/2 binary64)) #s(literal 2 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) (.f64 #s(approx (+ ( -1/6 (* re re)) 1) (.f64 (.f64 re re) #s(literal -1/6 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #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 (sin re) (.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))
(.f64 (fma.f64 (sin.f64 re) (exp.f64 im) #s(approx ( (exp (neg im)) (sin re)) #s(approx (* (exp (neg im)) re) re))) #s(literal 1/2 binary64))

Outputs

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

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

Calls

6 calls:

12.0ms	re
4.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
4.0ms	im
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
98.5%	2	`(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))`
79.7%	2	`(sin.f64 re)`
79.7%	2	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
98.5%	3	`(.f64 (.f64 #s(literal 1/2 binary64) (sin.f64 re)) (+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im)))`
79.2%	2	`re`
98.5%	2	`im`

Compiler

Compiled 27 to 30 computations (-11.1% saved)

regimes17.0ms (0.5%)

Memory

-29.6MiB live, 19.8MiB allocated; 3ms collecting garbage

Counts

11 → 3

Calls

Call 1

Inputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (* re 1/2) (* 2 (cosh im))) re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin.f64 re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (.f64 (exp.f64 (.f64 (log.f64 re) #s(literal 3 binary64))) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 (exp.f64 (log.f64 re)) #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (.f64 (pow.f64 (.f64 re re) #s(literal 3/2 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 (pow.f64 re #s(literal 3/2 binary64)) #s(literal 2 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) (.f64 #s(approx (+ ( -1/6 (* re re)) 1) (.f64 (.f64 re re) #s(literal -1/6 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #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 (sin re) (.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 #s(literal 2 binary64) (cosh.f64 im))))

Outputs

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

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

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

Calls

3 calls:

3.0ms	im
3.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 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))

Results

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

Compiler

Compiled 20 to 20 computations (0% saved)

regimes19.0ms (0.6%)

Memory

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

Counts

10 → 2

Calls

Call 1

Inputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (* re 1/2) (* 2 (cosh im))) re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) (sin.f64 re))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 re #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (.f64 (exp.f64 (.f64 (log.f64 re) #s(literal 3 binary64))) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 (exp.f64 (log.f64 re)) #s(literal 3 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (.f64 (pow.f64 (.f64 re re) #s(literal 3/2 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) #s(approx (* (+ (* -1/6 (* re re)) 1) re) (*.f64 (pow.f64 (pow.f64 re #s(literal 3/2 binary64)) #s(literal 2 binary64)) #s(literal -1/6 binary64)))))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (sin re) (.f64 #s(approx (+ ( -1/6 (* re re)) 1) (.f64 (.f64 re re) #s(literal -1/6 binary64))) re)))
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #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 (sin re) (.f64 (fma.f64 (.f64 #s(literal -1/6 binary64) re) re #s(literal 1 binary64)) re)))

Outputs

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

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

Calls

6 calls:

3.0ms	(sin.f64 re)
3.0ms	im
3.0ms	(*.f64 #s(literal 1/2 binary64) (sin.f64 re))
3.0ms	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
52.9%	1	`re`
52.9%	1	`(sin.f64 re)`
52.9%	1	`(*.f64 #s(literal 1/2 binary64) (sin.f64 re))`
60.2%	2	`(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))`
60.2%	2	`im`
60.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 27 to 30 computations (-11.1% saved)

regimes5.0ms (0.2%)

Memory

-38.4MiB live, 9.4MiB allocated; 1ms collecting garbage

Counts

2 → 1

Calls

Call 1

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

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

Calls

3 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)))
1.0ms	im
1.0ms	(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))

Results

Accuracy	Segments	Branch
52.9%	1	`(+.f64 (exp.f64 (-.f64 #s(literal 0 binary64) im)) (exp.f64 im))`
52.9%	1	`im`
52.9%	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 20 to 20 computations (0% saved)

regimes6.0ms (0.2%)

Memory

16.0MiB live, 16.0MiB allocated; 0ms 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 (* (* re 1/2) (* 2 (cosh im))) re))

Outputs
#s(approx (* (* 1/2 (sin re)) (+ (exp (- 0 im)) (exp im))) #s(approx (* (* re 1/2) (* 2 (cosh im))) re))

Calls

6 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)
1.0ms	re
1.0ms	im

Results

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

Compiler

Compiled 27 to 30 computations (-11.1% saved)

bsearch15.0ms (0.5%)

Memory

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

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
13.0ms	102.75499939414571	24186.703111370298

Samples

9.0ms

112×

valid

Compiler

Compiled 267 to 219 computations (18% saved)

Precisions

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

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

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

ival-mult!: 1.0ms (15.8% of total)

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

adjust: 0.0ms (0% of total)

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

bsearch1.0ms (0%)

Memory

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

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	7.920226258889082e+43	+inf
0.0ms	-inf	-0.999297614501062

Compiler

Compiled 15 to 16 computations (-6.7% saved)

bsearch2.0ms (0.1%)

Memory

-46.2MiB live, 1.3MiB allocated; 2ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-inf	-0.999297614501062

Compiler

Compiled 15 to 16 computations (-6.7% saved)

derivations231.0ms (7.5%)

Memory

5.6MiB live, 243.4MiB allocated; 14ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 258 to 72 computations (72.1% saved)

preprocess113.0ms (3.7%)

Memory

29.6MiB live, 315.4MiB allocated; 27ms collecting garbage

Remove

(negabs re)

(abs im)

Compiler

Compiled 1 968 to 1 020 computations (48.2% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze0.0ms (0%)

sample1.1s (35.1%)

explain118.0ms (3.8%)

preprocess30.0ms (1%)

series9.0ms (0.3%)

rewrite206.0ms (6.7%)

eval14.0ms (0.5%)

prune5.0ms (0.2%)

series32.0ms (1%)

rewrite252.0ms (8.2%)

eval35.0ms (1.1%)

prune11.0ms (0.4%)

series116.0ms (3.8%)

rewrite324.0ms (10.5%)

eval41.0ms (1.3%)

prune8.0ms (0.3%)

series17.0ms (0.5%)

rewrite189.0ms (6.1%)

eval37.0ms (1.2%)

prune11.0ms (0.4%)

regimes56.0ms (1.8%)

regimes56.0ms (1.8%)

regimes30.0ms (1%)

regimes17.0ms (0.5%)

regimes19.0ms (0.6%)

regimes5.0ms (0.2%)

regimes6.0ms (0.2%)

bsearch15.0ms (0.5%)

bsearch1.0ms (0%)

bsearch2.0ms (0.1%)

derivations231.0ms (7.5%)

preprocess113.0ms (3.7%)

end0.0ms (0%)

Profiling