Metrics for math.log10 on complex, real part

analyze62.0ms (0.7%)

Memory

-16.6MiB live, 138.6MiB allocated

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
0%	0%	99.9%	0.1%	0%	0%	0%	0
0%	0%	99.9%	0.1%	0%	0%	0%	1
0%	0%	99.9%	0.1%	0%	0%	0%	2
0%	0%	99.9%	0.1%	0%	0%	0%	3
0%	0%	99.9%	0.1%	0%	0%	0%	4
18.8%	18.7%	81.2%	0.1%	0%	0%	0%	5
34.4%	34.3%	65.6%	0.1%	0%	0%	0%	6
54.7%	54.6%	45.3%	0.1%	0%	0%	0%	7
64.8%	64.8%	35.1%	0.1%	0%	0%	0%	8
76.2%	76.1%	23.8%	0.1%	0%	0%	0%	9
81.8%	81.8%	18.1%	0.1%	0%	0%	0%	10
87.8%	87.7%	12.2%	0.1%	0%	0%	0%	11
90.8%	90.7%	9.2%	0.1%	0%	0%	0%	12

Compiler

Compiled 14 to 9 computations (35.7% saved)

sample974.0ms (10.4%)

Memory

6.8MiB live, 1 829.9MiB allocated

Samples

685.0ms

8 256×

valid

Precisions

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

ival-log: 216.0ms (46.2% of total)

ival-hypot: 150.0ms (32.1% of total)

ival-div: 89.0ms (19% of total)

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

exact: 5.0ms (1.1% of total)

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

Bogosity

preprocess21.0ms (0.2%)

Memory

15.6MiB live, 55.4MiB allocated

Algorithm

1×	egg-herbie

Rules

54×	`sub-neg`
34×	`neg-sub0`
30×	`distribute-lft-neg-in`
28×	`unsub-neg`
28×	`neg-mul-1`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	24	62
1	50	62
2	96	62
3	173	62
4	238	62
5	260	62
6	271	62
7	282	62
8	285	62
9	286	62
0	10	12
0	17	12
1	18	12
0	18	7

Stop Event

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

Calls

Call 1

Inputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))

Outputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))

Symmetry

(abs im)

(abs re)

(sort re im)

explain185.0ms (2%)

Memory

-25.1MiB live, 264.9MiB allocated

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
120	-	1	(1.470240375427601e-275 2.1756481397908827e-162)	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
0	-	0	-	`(log.f64 #s(literal 10 binary64))`
0	-	0	-	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
0	-	0	-	`(*.f64 re re)`
0	-	0	-	`im`
0	-	0	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	0	-	`re`
0	-	0	-	`(*.f64 im im)`
0	-	0	-	`#s(literal 10 binary64)`
0	-	0	-	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`

Explanations

Click to see full explanations table

Operator	Subexpression	Explanation	Count
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	oflow-rescue	105	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	105
↳	`(*.f64 re re)`	overflow	19
↳	`(*.f64 im im)`	overflow	105
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	14	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	14
↳	`(*.f64 re re)`	underflow	114
↳	`(*.f64 im im)`	underflow	14

Confusion

	Predicted +	Predicted -
+	119	1
-	0	136

Precision

1.0

Recall

0.9916666666666667

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	119	0	1
-	0	0	136

Precision?

1.0

Recall?

0.9916666666666667

Freqs

test

number	freq
0	137
1	119

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

103.0ms

512×

valid

Compiler

Compiled 126 to 44 computations (65.1% saved)

Precisions

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

ival-log: 30.0ms (59.9% of total)

ival-hypot: 8.0ms (16% of total)

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

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

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

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

exact: 0.0ms (0% of total)

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

eval0.0ms (0%)

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

prune1.0ms (0%)

Memory

1.8MiB live, 1.8MiB allocated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	54.2%	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 14 to 10 computations (28.6% saved)

simplify4.0ms (0%)

Memory

9.8MiB live, 9.8MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

New	Metric	Score	Program
✓	cost-diff	0	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
✓	cost-diff	0	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
✓	cost-diff	0	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
✓	cost-diff	128	(+.f64 (.f64 re re) (.f64 im im))

Rules

4×	`lower-hypot.f32`
4×	`lower-hypot.f64`
4×	`lower-fma.f64`
4×	`lift-*.f64`
4×	`lower-fma.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	10	47
0	17	47
1	18	47
0	18	31

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(+.f64 (.f64 re re) (.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)

Outputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(+.f64 (.f64 re re) (.f64 im im))
(fma.f64 re re (*.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)

localize38.0ms (0.4%)

Memory

21.8MiB live, 98.9MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score	Program
✓	accuracy	100.0%	(log.f64 #s(literal 10 binary64))
✓	accuracy	100.0%	(+.f64 (.f64 re re) (.f64 im im))
✓	accuracy	99.0%	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
✓	accuracy	56.4%	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Samples

26.0ms

256×

valid

Compiler

Compiled 49 to 12 computations (75.5% saved)

Precisions

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

ival-log: 6.0ms (34.8% of total)

ival-hypot: 5.0ms (29% of total)

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

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

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

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

exact: 0.0ms (0% of total)

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

series14.0ms (0.2%)

Memory

-26.1MiB live, 14.5MiB allocated

Counts

5 → 96

Calls

Call 1

Inputs
#<alt (+.f64 (.f64 re re) (.f64 im im))>
#<alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))>
#<alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))>
#<alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))>
#<alt (log.f64 #s(literal 10 binary64))>

Outputs
#<alt (pow im 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))>
#<alt (pow re 2)>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (+ (pow im 2) (pow re 2))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (pow im 2)>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))>
#<alt (/ (log im) (log 10))>
#<alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))>
#<alt (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))>
#<alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))>
#<alt (* -1 (/ (log (/ 1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (/ (log re) (log 10))>
#<alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))>
#<alt (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))>
#<alt (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (log im)>
#<alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (* -1 (log (/ 1 re)))>
#<alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (log (/ -1 re)))>
#<alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (log re)>
#<alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))>
#<alt re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))>

Calls

24 calls:

Time	Variable		Point	Expression
3.0ms	im	@	0	(+ (* re re) (* im im))
2.0ms	re	@	0	(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
2.0ms	im	@	inf	(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
1.0ms	re	@	inf	(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))
1.0ms	im	@	0	(/ (log (sqrt (+ (* re re) (* im im)))) (log 10))

rewrite303.0ms (3.2%)

Memory

30.5MiB live, 502.5MiB allocated

Algorithm

1×	batch-egg-rewrite

Rules

4 802×	`lower-fma.f64`
4 802×	`lower-fma.f32`
3 340×	`lower-*.f32`
3 336×	`lower-*.f64`
3 206×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	10	38
0	17	38
1	44	38
2	251	38
3	2046	38
0	8387	22

Stop Event

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

Counts

5 → 311

Calls

Call 1

Inputs
(+.f64 (.f64 re re) (.f64 im im))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(log.f64 #s(literal 10 binary64))

Outputs
(+.f64 (.f64 re re) (.f64 im im))
(+.f64 (.f64 im im) (.f64 re re))
(+.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im)))))
(exp.f64 (log.f64 (fma.f64 im im (*.f64 re re))))
(exp.f64 (.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1 binary64)))
(-.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 im re))))
(-.f64 (/.f64 (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (/.f64 (/.f64 (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (/.f64 (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))) (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (.f64 re re)))))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (.f64 re re)))))) (.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (/.f64 (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (.f64 re re)))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im))))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 (.f64 (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im))))) (.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))) (/.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))) (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))) (/.f64 (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))))
(-.f64 (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (.f64 re re))))))) (/.f64 (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (.f64 re re))))))))
(-.f64 (/.f64 (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))))) (/.f64 (.f64 (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))))))
(-.f64 (/.f64 (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))))))) (/.f64 (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))))))))
(-.f64 (/.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (/.f64 (.f64 re (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))))) (/.f64 (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (/.f64 (.f64 re (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 re re (*.f64 im im))
(fma.f64 re (/.f64 (.f64 re (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (.f64 re re) (/.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 im im (*.f64 re re))
(fma.f64 (.f64 re (.f64 re (.f64 re re))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (.f64 re (.f64 re re)) (/.f64 re (.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 re (+.f64 re im)) (/.f64 (.f64 re (.f64 re re)) (-.f64 re im)) (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (.f64 re re) (+.f64 re im)) (/.f64 (.f64 re re) (-.f64 re im)) (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (.f64 re (.f64 re re)) (+.f64 re im)) (/.f64 re (-.f64 re im)) (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 im im (.f64 re re)) (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (fma.f64 (.f64 im im) (fma.f64 im im (.f64 re re)) (.f64 re (.f64 re (.f64 re re)))) (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (/.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(neg.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (fma.f64 im im (.f64 re re))))
(neg.f64 (-.f64 (/.f64 #s(literal 0 binary64) (.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 im im (.f64 re re))))
(/.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (exp.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (fma.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))) (.f64 (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))))) (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (-.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 re (.f64 re (*.f64 re re)))))))))
(/.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))))
(/.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (*.f64 re re)))))))
(/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (+.f64 re im) (-.f64 im re)))
(/.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im))))))
(/.f64 (-.f64 (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (.f64 (fma.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))) (.f64 (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))))) #s(literal 1 binary64)) (.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (-.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) #s(literal 1 binary64)) (.f64 (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) #s(literal 1 binary64)) (.f64 (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (.f64 re re))))) (.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64)) (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))) (.f64 (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))))) (neg.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (-.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 re (.f64 re (*.f64 re re))))))))))
(/.f64 (neg.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))) (neg.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))))
(/.f64 (neg.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))) (neg.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (*.f64 re re))))))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (neg.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))))) (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im)))))) (fma.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im)))) (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))))) (fma.f64 re (/.f64 (.f64 re (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) #s(literal 1 binary64)) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (.f64 (fma.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))) (.f64 (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))) (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (-.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 re (.f64 re (*.f64 re re))))))))
(/.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))
(/.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (*.f64 re re))))))
(/.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))))
(/.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im)) (-.f64 re im))
(/.f64 (exp.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (exp.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (exp.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (exp.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (exp.f64 (log.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (exp.f64 (log.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (exp.f64 (log.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))))) (exp.f64 (log.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (exp.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (exp.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (-.f64 (neg.f64 (.f64 re (.f64 re (.f64 re re)))) (neg.f64 (.f64 im (.f64 im (.f64 im im))))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (.f64 (.f64 re (.f64 re (.f64 re re))) (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) #s(literal 1 binary64))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))))
(/.f64 (-.f64 (.f64 (.f64 re (.f64 re (.f64 re re))) (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (neg.f64 (.f64 im (.f64 im (.f64 im im)))))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (.f64 (.f64 re (.f64 re (.f64 re re))) (-.f64 re im)) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (/.f64 (.f64 im (.f64 im (.f64 im im))) (+.f64 re im)))) (.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (-.f64 re im)))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 re (.f64 re (.f64 re re)))) (.f64 im (.f64 im (.f64 im im))))) (.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 re (.f64 re (.f64 re re)))) (.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 re (.f64 re (.f64 re re)))) #s(literal 1 binary64))) (.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 re (.f64 re (.f64 re re)))) (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im))))))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))) (.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 re (.f64 re (.f64 re re)))) (neg.f64 (.f64 im (.f64 im (.f64 im im)))))) (.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 re (.f64 re (.f64 re re)))) (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (.f64 #s(literal 1 binary64) (-.f64 re im)) (.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 re (.f64 re (.f64 re re)))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (+.f64 re im)))) (.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 re (.f64 re (.f64 re re)))) (-.f64 re im)))
(/.f64 (-.f64 (.f64 (neg.f64 (.f64 re (.f64 re (.f64 re re)))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))) (.f64 im (.f64 im (.f64 im im))))) (.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (.f64 (neg.f64 (.f64 re (.f64 re (.f64 re re)))) (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1 binary64))) (.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))))
(/.f64 (-.f64 (.f64 (neg.f64 (.f64 re (.f64 re (.f64 re re)))) (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))) (.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (.f64 im (.f64 im (.f64 im im)))))) (.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (.f64 (neg.f64 (.f64 re (.f64 re (.f64 re re)))) (-.f64 re im)) (.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (+.f64 re im)))) (.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 re im)))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (+.f64 re im)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (-.f64 re im) (.f64 im (.f64 im (.f64 im im))))) (.f64 (-.f64 re im) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (+.f64 re im)) (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (.f64 (-.f64 re im) #s(literal 1 binary64))) (.f64 (-.f64 re im) (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (+.f64 re im)) (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))) (.f64 (-.f64 re im) (neg.f64 (.f64 im (.f64 im (.f64 im im)))))) (.f64 (-.f64 re im) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (+.f64 re im)) (-.f64 re im)) (.f64 (-.f64 re im) (/.f64 (.f64 im (.f64 im (.f64 im im))) (+.f64 re im)))) (*.f64 (-.f64 re im) (-.f64 re im)))
(/.f64 (-.f64 (.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (.f64 re (.f64 re (.f64 re re))))) (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (neg.f64 (-.f64 (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))) (neg.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))) (.f64 (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (-.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (.f64 (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) #s(literal 1 binary64))) (neg.f64 (.f64 (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (.f64 re re))))) (.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64))) (neg.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (neg.f64 (neg.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (neg.f64 (neg.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (neg.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))))) (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))))))) (neg.f64 (fma.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 (neg.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im)))) (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (fma.f64 re (/.f64 (.f64 re (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) #s(literal 1 binary64))) (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))) (.f64 (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))) (neg.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (-.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 re (.f64 re (*.f64 re re)))))))))
(/.f64 (neg.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))) (neg.f64 (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))))
(/.f64 (neg.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (*.f64 re re)))))))
(/.f64 (neg.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im))))))
(/.f64 (neg.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))) (neg.f64 (-.f64 re im)))
(/.f64 (fma.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im)))) (pow.f64 (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (-.f64 (.f64 (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))))) (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1 binary64))
(pow.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal -1 binary64))
(.f64 (fma.f64 im im (.f64 re re)) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(.f64 (fma.f64 im im (.f64 re re)) (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 (+.f64 re im) (-.f64 re im))))
(.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (fma.f64 im im (.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))
(.f64 #s(literal 1 binary64) (fma.f64 im im (.f64 re re)))
(.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))
(.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (*.f64 im im)))))
(.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (*.f64 im im))))) #s(literal -1 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))))
(.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))) (pow.f64 (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal -1 binary64)))
(.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))))
(.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) (+.f64 re im))
(.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 im im (.f64 re re)))
(.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (pow.f64 (/.f64 (-.f64 re im) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) #s(literal -1 binary64)))
(.f64 (/.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (fma.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))))) (fma.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (*.f64 re re))))))
(.f64 (/.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))) (-.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))
(.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (fma.f64 (.f64 im im) (fma.f64 im im (.f64 re re)) (.f64 re (.f64 re (*.f64 re re)))))
(.f64 (pow.f64 (/.f64 (+.f64 re im) (fma.f64 im im (.f64 re re))) #s(literal -1 binary64)) (pow.f64 (/.f64 (-.f64 re im) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (*.f64 re re)))))))
(.f64 (pow.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im))))))
(.f64 (pow.f64 (/.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))) (.f64 (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (-.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 re (.f64 re (*.f64 re re)))))))))
(.f64 (pow.f64 (/.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))))
(.f64 (exp.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (exp.f64 (neg.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(.f64 (exp.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (exp.f64 (neg.f64 (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (.f64 #s(literal 1 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (.f64 #s(literal 1 binary64) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1 binary64)))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (.f64 #s(literal 1 binary64) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1/2 binary64))
(pow.f64 (exp.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))))) #s(literal -1 binary64))
(.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal 1/2 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 #s(literal 1 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))))
(.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))))
(.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1 binary64)) #s(literal -1 binary64)))
(.f64 #s(literal -1 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(.f64 (.f64 #s(literal 1 binary64) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(+.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/4 binary64)) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/4 binary64)))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 #s(literal 0 binary64) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))
(-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (log.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(-.f64 (log.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (sqrt.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 (log.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (log.f64 (neg.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (neg.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/4 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)))
(fma.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 im im (.f64 re re))) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)))
(neg.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/4 binary64)) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/4 binary64)) #s(literal 3 binary64))) (fma.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/4 binary64)) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/4 binary64)) (-.f64 (.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/4 binary64)) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/4 binary64))) (.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/4 binary64)) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/4 binary64))))))
(.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
(.f64 #s(literal 1/2 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)))
(.f64 #s(literal 2 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)))
(.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
(.f64 #s(literal -1 binary64) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 #s(literal 1/4 binary64) (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (fma.f64 im im (.f64 re re)))))
(exp.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))
(exp.f64 (.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (fma.f64 im im (.f64 re re)))) #s(literal 1/4 binary64)))
(hypot.f64 re im)
(hypot.f64 im re)
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (sqrt.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (hypot.f64 (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 re (.f64 re re))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (sqrt.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (-.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))))))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))) (sqrt.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))) (sqrt.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (*.f64 re re))))))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (neg.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (exp.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (exp.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (exp.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))))) (exp.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))))
(/.f64 (sqrt.f64 (-.f64 (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))) (sqrt.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))) (.f64 (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (-.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (sqrt.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (.f64 (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (sqrt.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) #s(literal 1 binary64))) (sqrt.f64 (.f64 (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (.f64 re re))))) (.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64))) (sqrt.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (sqrt.f64 (neg.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (sqrt.f64 (neg.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))))) (sqrt.f64 (neg.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (sqrt.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))))) (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))))))) (sqrt.f64 (fma.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(/.f64 (sqrt.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im)))) (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im)))))) (sqrt.f64 (fma.f64 re (/.f64 (.f64 re (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) #s(literal 1 binary64))) (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))) (.f64 (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))) (sqrt.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (-.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 re (.f64 re (*.f64 re re)))))))))
(/.f64 (sqrt.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))) (sqrt.f64 (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))))
(/.f64 (sqrt.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (*.f64 re re)))))))
(/.f64 (sqrt.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im))))))
(/.f64 (sqrt.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))) (sqrt.f64 (-.f64 re im)))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (sqrt.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))))) (neg.f64 (neg.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (.f64 (fma.f64 im im (.f64 re re)) (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1 binary64)))
(pow.f64 (exp.f64 #s(literal 1 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))
(.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (pow.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (pow.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (sqrt.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (sqrt.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 (+.f64 re im) (-.f64 re im)))))
(.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (.f64 re re))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (pow.f64 (.f64 (fma.f64 im im (.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (pow.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))) (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (*.f64 im im))))))
(.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(.f64 (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im im (.f64 re re))))
(.f64 (pow.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im im (.f64 re re))))
(.f64 (pow.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 re im)))
(.f64 (pow.f64 (/.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (fma.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re))))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (*.f64 re re)))))))
(.f64 (pow.f64 (/.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))) #s(literal 1/2 binary64)) (sqrt.f64 (-.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))
(.f64 (pow.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (.f64 im im) (fma.f64 im im (.f64 re re)) (.f64 re (.f64 re (*.f64 re re))))))
(.f64 (pow.f64 (pow.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(.f64 (pow.f64 (pow.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (*.f64 (+.f64 re im) (-.f64 re im)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(.f64 (sqrt.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (fma.f64 im im (.f64 re re))))
(.f64 (sqrt.f64 (/.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (fma.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re re) (.f64 re (.f64 re (.f64 re re)))))))) (sqrt.f64 (fma.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 re (.f64 re (*.f64 re re)))))))
(.f64 (sqrt.f64 (/.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))) (sqrt.f64 (-.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))
(.f64 (sqrt.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))) (sqrt.f64 (fma.f64 (.f64 im im) (fma.f64 im im (.f64 re re)) (.f64 re (.f64 re (*.f64 re re))))))
(log.f64 #s(literal 10 binary64))
(exp.f64 (neg.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))

simplify507.0ms (5.4%)

Memory

-4.6MiB live, 742.6MiB allocated

Algorithm

1×	egg-herbie

Rules

14 804×	`lower-fma.f64`
14 804×	`lower-fma.f32`
4 746×	`lower-*.f64`
4 746×	`lower-*.f32`
3 910×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	268	1640
1	730	1596
2	2198	1594
3	5817	1582
0	8414	1470

Stop Event

1×	iter limit
1×	node limit

Counts

96 → 92

Calls

Call 1

Inputs
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(/ (log re) (log 10))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))

Outputs
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 im im (*.f64 re re))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(+ (pow im 2) (pow re 2))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 im im (*.f64 re re))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im im) (.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (.f64 im (.f64 im (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re re) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im im) (.f64 im im))))) (/.f64 #s(literal 1/2 binary64) (.f64 im (.f64 im (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 im (/.f64 (.f64 im #s(literal 1/2 binary64)) (.f64 re (*.f64 re (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (.f64 re (.f64 re (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (.f64 re (.f64 re (log.f64 #s(literal 10 binary64)))))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(-.f64 (/.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) (.f64 re (.f64 re (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (.f64 re (.f64 re (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (.f64 re (.f64 re (log.f64 #s(literal 10 binary64)))))) (-.f64 (/.f64 (.f64 #s(literal 1/720 binary64) (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))
(/ (log re) (log 10))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(fma.f64 im (/.f64 (.f64 im #s(literal 1/2 binary64)) (.f64 re (*.f64 re (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (.f64 re (.f64 re (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 re re) (.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (.f64 re (.f64 re (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im (*.f64 im (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im im) (.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (.f64 im (.f64 im (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im im) (.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (.f64 im (.f64 im (log.f64 #s(literal 10 binary64)))))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(-.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (.f64 im (.f64 im (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im im) (.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (.f64 im (.f64 im (log.f64 #s(literal 10 binary64)))))) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im im) (.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (.f64 im (.f64 im (log.f64 #s(literal 10 binary64)))))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im im)) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re #s(literal -1/4 binary64)) (/.f64 re (.f64 (.f64 im im) (.f64 im im))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 re (.f64 re (fma.f64 (.f64 re re) (/.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (.f64 im im) (.f64 im im))))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 im (/.f64 (.f64 im #s(literal 1/2 binary64)) (.f64 re re)) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal -1/4 binary64) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal -1/4 binary64) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (log.f64 re)))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) (*.f64 re re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal -1/4 binary64) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal -1/4 binary64) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (/.f64 (.f64 #s(literal 1/720 binary64) (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 im (/.f64 (.f64 im #s(literal 1/2 binary64)) (.f64 re re)) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal -1/4 binary64) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 im (.f64 im (fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))) (log.f64 re))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re #s(literal -1/4 binary64)) (/.f64 re (.f64 (.f64 im im) (.f64 im im))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re #s(literal -1/4 binary64)) (/.f64 re (.f64 (.f64 im im) (.f64 im im))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (log.f64 im)))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re #s(literal -1/4 binary64)) (/.f64 re (.f64 (.f64 im im) (.f64 im im))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 (.f64 re re) (fma.f64 (.f64 re #s(literal -1/4 binary64)) (/.f64 re (.f64 (.f64 im im) (.f64 im im))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (/.f64 #s(literal -1/8 binary64) (.f64 im (.f64 im im))) (/.f64 #s(literal 1/2 binary64) im)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) re) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (fma.f64 (.f64 (.f64 im im) (.f64 im im)) (/.f64 #s(literal -1/8 binary64) (.f64 (.f64 re re) (.f64 re re))) (/.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) (*.f64 re re))) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (fma.f64 (.f64 (.f64 im im) (.f64 im im)) (/.f64 #s(literal -1/8 binary64) (.f64 (.f64 re re) (.f64 re re))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/16 binary64)) (pow.f64 re #s(literal 6 binary64))))) re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -1 binary64) (/.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) re) (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(.f64 re (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal 1/8 binary64) (fma.f64 (.f64 im #s(literal -1/2 binary64)) (/.f64 im (*.f64 re re)) #s(literal -1 binary64))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(fma.f64 re (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/16 binary64) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal 1/8 binary64) #s(literal -1 binary64))) (.f64 #s(literal -1 binary64) (/.f64 (.f64 (*.f64 im im) #s(literal 1/2 binary64)) re)))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (*.f64 im im) (/.f64 #s(literal 1/2 binary64) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 im (.f64 im (fma.f64 (.f64 im im) (/.f64 #s(literal -1/8 binary64) (.f64 re (.f64 re re))) (/.f64 #s(literal 1/2 binary64) re))) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal -1/8 binary64)) (.f64 (.f64 im im) (.f64 im im))) (fma.f64 #s(literal 1 binary64) (/.f64 (.f64 (*.f64 re re) #s(literal 1/2 binary64)) im) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im im)) (fma.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal -1/8 binary64) (.f64 (.f64 im im) (.f64 im im))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/16 binary64)) (pow.f64 im #s(literal 6 binary64))))) im)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal -1 binary64) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) im) (neg.f64 im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64)) (.f64 #s(literal -1 binary64) (/.f64 (.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(fma.f64 im (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/16 binary64) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal 1/8 binary64) #s(literal -1 binary64))) (.f64 #s(literal -1 binary64) (/.f64 (.f64 (*.f64 re re) #s(literal 1/2 binary64)) im)))

eval60.0ms (0.6%)

Memory: 22.4MiB live, 102.4MiB allocated
Compiler: Compiled 16 389 to 1 712 computations (89.6% saved)

prune121.0ms (1.3%)

Memory

-0.5MiB live, 118.5MiB allocated

Pruning

15 alts after pruning (15 fresh and 0 done)

	Pruned	Kept	Total
New	388	15	403
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	389	15	404

Accuracy

99.5%

Counts

404 → 15

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	35.7%	(pow.f64 (pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
	36.0%	(pow.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1/2 binary64))
	54.2%	(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
	16.9%	(/.f64 (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
	54.2%	(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))))
	54.2%	(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
	54.2%	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
▶	98.3%	(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
	54.2%	(/.f64 (log.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 10 binary64)))
▶	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶	54.2%	(/.f64 (log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))) (log.f64 #s(literal 10 binary64)))
	27.5%	(/.f64 (log.f64 (sqrt.f64 (/.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (+.f64 re im)) (-.f64 re im)) (.f64 (-.f64 re im) (/.f64 (.f64 im (.f64 im (.f64 im im))) (+.f64 re im)))) (*.f64 (-.f64 re im) (-.f64 re im))))) (log.f64 #s(literal 10 binary64)))
▶	97.9%	(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
	54.3%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))))
	16.8%	(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))) (log.f64 #s(literal 10 binary64))))

Compiler

Compiled 730 to 416 computations (43% saved)

simplify13.0ms (0.1%)

Memory

-19.7MiB live, 16.0MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 19 expressions of interest:

New	Metric	Score	Program
✓	cost-diff	0	(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
✓	cost-diff	0	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
✓	cost-diff	5824	(pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
✓	cost-diff	7104	(pow.f64 (pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
✓	cost-diff	0	(sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))
✓	cost-diff	0	(.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
✓	cost-diff	0	(log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))
✓	cost-diff	0	(/.f64 (log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))) (log.f64 #s(literal 10 binary64)))
✓	cost-diff	0	(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
✓	cost-diff	0	(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
✓	cost-diff	0	(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
✓	cost-diff	0	(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
✓	cost-diff	0	(log.f64 #s(literal 10 binary64))
✓	cost-diff	0	(log.f64 im)
✓	cost-diff	0	(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
✓	cost-diff	0	(log.f64 #s(literal 10 binary64))
✓	cost-diff	0	(log.f64 (hypot.f64 re im))
✓	cost-diff	0	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	cost-diff	5120	(hypot.f64 re im)

Rules

62×	`lower-*.f32`
54×	`lower-*.f64`
26×	`lower-/.f32`
20×	`lower-fma.f32`
18×	`*-commutative`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	30	242
0	58	243
1	72	237
2	87	237
3	95	237
4	103	237
5	105	237
0	105	237

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (hypot.f64 re im))
(hypot.f64 re im)
re
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(log.f64 im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
re
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(/.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))
(.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))
(/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))
(fma.f64 im im (*.f64 re re))
im
(*.f64 re re)
re
(+.f64 re im)
(sqrt.f64 (+.f64 re im))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(pow.f64 (pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
#s(literal 1/2 binary64)
(log.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 im im (*.f64 re re))
im
(*.f64 re re)
re
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(literal 2 binary64)

Outputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (hypot.f64 re im))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(hypot.f64 re im)
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
re
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(log.f64 im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(log.f64 (fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(fma.f64 re (/.f64 (*.f64 re #s(literal 1/2 binary64)) im) im)
re
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(/.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 re re (.f64 im im)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))
(log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 re re (.f64 im im)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))
(.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(.f64 (sqrt.f64 (/.f64 (fma.f64 re re (.f64 im im)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))
(sqrt.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im)))
(/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))
(/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
im
(*.f64 re re)
re
(+.f64 re im)
(sqrt.f64 (+.f64 re im))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(pow.f64 (pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(.f64 (log.f64 (fma.f64 re re (.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(sqrt.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(.f64 (log.f64 (fma.f64 re re (.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
#s(literal 1/2 binary64)
(log.f64 (fma.f64 im im (*.f64 re re)))
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
im
(*.f64 re re)
re
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(literal 2 binary64)

localize133.0ms (1.4%)

Memory

-29.5MiB live, 230.6MiB allocated

Localize:

Found 19 expressions of interest:

New	Metric	Score	Program
✓	accuracy	99.8%	(pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
✓	accuracy	99.4%	(pow.f64 (pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
✓	accuracy	99.3%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
✓	accuracy	60.3%	(log.f64 (fma.f64 im im (*.f64 re re)))
✓	accuracy	100.0%	(sqrt.f64 (+.f64 re im))
✓	accuracy	99.4%	(.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
✓	accuracy	99.3%	(/.f64 (log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))) (log.f64 #s(literal 10 binary64)))
✓	accuracy	61.8%	(/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))
✓	accuracy	100.0%	(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
✓	accuracy	100.0%	(log.f64 #s(literal 10 binary64))
✓	accuracy	99.8%	(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
✓	accuracy	99.3%	(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
✓	accuracy	100.0%	(log.f64 im)
✓	accuracy	100.0%	(log.f64 #s(literal 10 binary64))
✓	accuracy	99.3%	(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
✓	accuracy	100.0%	(hypot.f64 re im)
✓	accuracy	100.0%	(log.f64 (hypot.f64 re im))
✓	accuracy	100.0%	(log.f64 #s(literal 10 binary64))
✓	accuracy	99.3%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))

Samples

65.0ms	194×	0	valid
17.0ms	62×	0	invalid

Compiler

Compiled 274 to 34 computations (87.6% saved)

Precisions

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

ival-log: 17.0ms (27.1% of total)

ival-sqrt: 15.0ms (23.9% of total)

ival-div: 11.0ms (17.5% of total)

ival-mult: 8.0ms (12.8% of total)

ival-hypot: 6.0ms (9.6% of total)

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

ival-pow2: 2.0ms (3.2% of total)

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

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

exact: 0.0ms (0% of total)

series136.0ms (1.5%)

Memory

17.3MiB live, 250.9MiB allocated

Counts

21 → 456

Calls

Call 1

Inputs
#<alt (hypot.f64 re im)>
#<alt (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))>
#<alt (log.f64 (hypot.f64 re im))>
#<alt (log.f64 #s(literal 10 binary64))>
#<alt (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))>
#<alt (log.f64 im)>
#<alt (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))>
#<alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))>
#<alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)>
#<alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im))>
#<alt (/.f64 (log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))) (log.f64 #s(literal 10 binary64)))>
#<alt (log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))>
#<alt (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))>
#<alt (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))>
#<alt (pow.f64 (pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))>
#<alt (pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))>
#<alt (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))>
#<alt (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))>
#<alt (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))>
#<alt (sqrt.f64 (+.f64 re im))>
#<alt (log.f64 (fma.f64 im im (*.f64 re re)))>

Outputs
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))>
#<alt re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))>
#<alt (/ (log im) (log 10))>
#<alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))>
#<alt (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))>
#<alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))>
#<alt (* -1 (/ (log (/ 1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (/ (log re) (log 10))>
#<alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))>
#<alt (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))>
#<alt (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (log im)>
#<alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (* -1 (log (/ 1 re)))>
#<alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (log (/ -1 re)))>
#<alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (log re)>
#<alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (/ (log im) (log 10))>
#<alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))>
#<alt (+ (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))>
#<alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/8 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))>
#<alt (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 10))>
#<alt (+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))>
#<alt (+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))))>
#<alt (+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (+ (* 8/3 (/ (pow im 6) (* (pow re 6) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))))>
#<alt (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 10))>
#<alt (+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))>
#<alt (+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))))>
#<alt (+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (+ (* 8/3 (/ (pow im 6) (* (pow re 6) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))))>
#<alt (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 10))>
#<alt (+ (* -1 (/ (log im) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (* 1/2 (pow re 2))) (log 10))))>
#<alt (+ (* -1 (/ (log im) (log 10))) (+ (* (pow im 2) (+ (* -2 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log (* 1/2 (pow re 2))) (log 10))))>
#<alt (+ (* -1 (/ (log im) (log 10))) (+ (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 2 (/ 1 (* (pow re 4) (log 10)))))) (* 2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log (* 1/2 (pow re 2))) (log 10))))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/24 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/24 (/ (pow re 6) (* (pow im 6) (log 10)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))>
#<alt (log im)>
#<alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))>
#<alt (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))>
#<alt (+ (log (* 1/2 (pow re 2))) (* -1 (log im)))>
#<alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2)))))))>
#<alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2)))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (* 1/2 (/ (pow re 2) im))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* 1/2 (/ (pow re 2) im))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* 1/2 (/ (pow re 2) im))>
#<alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)>
#<alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)>
#<alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt im>
#<alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))>
#<alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))>
#<alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (/ (log re) (log 10))>
#<alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))>
#<alt (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))>
#<alt (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (/ (log im) (log 10))>
#<alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))>
#<alt (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))>
#<alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))>
#<alt (* -1 (/ (log (/ 1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (log re)>
#<alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (log im)>
#<alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (* -1 (log (/ 1 re)))>
#<alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (log (/ -1 re)))>
#<alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))>
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))>
#<alt (sqrt re)>
#<alt (+ (sqrt re) (* -1/2 (* im (sqrt (/ 1 re)))))>
#<alt (+ (sqrt re) (* im (+ (* -1/2 (sqrt (/ 1 re))) (* 7/8 (* im (sqrt (/ 1 (pow re 3))))))))>
#<alt (+ (sqrt re) (* im (+ (* -1/2 (sqrt (/ 1 re))) (* im (+ (* -9/16 (* im (sqrt (/ 1 (pow re 5))))) (* 7/8 (sqrt (/ 1 (pow re 3)))))))))>
#<alt (sqrt im)>
#<alt (* im (+ (sqrt (/ 1 im)) (* -1/2 (* (sqrt (/ 1 (pow im 3))) re))))>
#<alt (* im (+ (sqrt (/ 1 im)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* 1/2 (* (sqrt (/ 1 (pow im 5))) (- (pow re 2) (* -1 (pow re 2))))))))>
#<alt (* im (+ (sqrt (/ 1 im)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 7))) (+ (* 1/4 (* im (pow re 2))) (* re (- (pow re 2) (* -1 (pow re 2))))))) (* 1/2 (* (sqrt (/ 1 (pow im 5))) (- (pow re 2) (* -1 (pow re 2)))))))))>
#<alt (* -1 (* (sqrt im) (pow (sqrt -1) 2)))>
#<alt (* -1 (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))>
#<alt (* -1 (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 5))) (- (* -1 (pow re 2)) (pow re 2)))) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))>
#<alt (* -1 (* im (+ (* -1 (/ (+ (* 1/2 (* (sqrt im) (- (* -1 (pow re 2)) (pow re 2)))) (* 1/2 (* (sqrt (/ 1 im)) (+ (* -1 (* re (- (* -1 (pow re 2)) (pow re 2)))) (* -1/4 (/ (* im (pow re 2)) (pow (sqrt -1) 2))))))) (pow im 3))) (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))>
#<alt (sqrt im)>
#<alt (+ (sqrt im) (* -1/2 (* (sqrt (/ 1 im)) re)))>
#<alt (+ (sqrt im) (* re (+ (* -1/2 (sqrt (/ 1 im))) (* 7/8 (* (sqrt (/ 1 (pow im 3))) re)))))>
#<alt (+ (sqrt im) (* re (+ (* -1/2 (sqrt (/ 1 im))) (* re (+ (* -9/16 (* (sqrt (/ 1 (pow im 5))) re)) (* 7/8 (sqrt (/ 1 (pow im 3)))))))))>
#<alt (sqrt re)>
#<alt (* re (+ (sqrt (/ 1 re)) (* -1/2 (* im (sqrt (/ 1 (pow re 3)))))))>
#<alt (* re (+ (sqrt (/ 1 re)) (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 (pow re 5))) (- (pow im 2) (* -1 (pow im 2))))))))>
#<alt (* re (+ (sqrt (/ 1 re)) (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (+ (* -1/2 (* (sqrt (/ 1 (pow re 7))) (+ (* 1/4 (* (pow im 2) re)) (* im (- (pow im 2) (* -1 (pow im 2))))))) (* 1/2 (* (sqrt (/ 1 (pow re 5))) (- (pow im 2) (* -1 (pow im 2)))))))))>
#<alt (* -1 (* (sqrt re) (pow (sqrt -1) 2)))>
#<alt (* -1 (* re (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))>
#<alt (* -1 (* re (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (+ (* -1/2 (* (sqrt (/ 1 (pow re 5))) (- (* -1 (pow im 2)) (pow im 2)))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2))))))>
#<alt (* -1 (* re (+ (* -1 (/ (+ (* 1/2 (* (sqrt re) (- (* -1 (pow im 2)) (pow im 2)))) (* 1/2 (* (sqrt (/ 1 re)) (+ (* -1 (* im (- (* -1 (pow im 2)) (pow im 2)))) (* -1/4 (/ (* (pow im 2) re) (pow (sqrt -1) 2))))))) (pow re 3))) (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2))))))>
#<alt (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10))>
#<alt (+ (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))>
#<alt (+ (* (pow im 2) (+ (* -1/2 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))>
#<alt (+ (* (pow im 2) (+ (* (pow im 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow re 4) (log 10)))) (* 1/3 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))>
#<alt (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10)))>
#<alt (+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))>
#<alt (+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))>
#<alt (+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))>
#<alt (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10)))>
#<alt (+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))>
#<alt (+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))>
#<alt (+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))>
#<alt (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10))>
#<alt (+ (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))>
#<alt (+ (* (pow re 2) (+ (* -1/2 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))>
#<alt (+ (* (pow re 2) (+ (* (pow re 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow im 4) (log 10)))) (* 1/3 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))>
#<alt (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10)))>
#<alt (+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))>
#<alt (+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))>
#<alt (+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))>
#<alt (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10)))>
#<alt (+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))>
#<alt (+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))>
#<alt (+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))>
#<alt (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2))>
#<alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)))>
#<alt (+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* -1/2 (* (/ (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2)))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow re 2)))))) (* 1/4 (* (/ 1 (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))))))>
#<alt (+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* 1/4 (* (/ 1 (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow re 2)))) (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow im 2) (- (* 1/6 (/ 1 (* (pow re 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (* (pow re 2) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow re 2)))))))))))>
#<alt (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))>
#<alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))>
#<alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))))>
#<alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow re 6) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2))))))) (* (log (/ 1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))))>
#<alt (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))>
#<alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))>
#<alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))))>
#<alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow re 6) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2))))))) (* (log (/ -1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))))>
#<alt (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2))>
#<alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)))>
#<alt (+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* -1/2 (* (/ (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2)))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow im 2)))))) (* 1/4 (* (/ 1 (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))))))>
#<alt (+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* 1/4 (* (/ 1 (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (pow re 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow im 2)))) (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow re 2) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (* (pow im 2) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow im 2)))))))))))>
#<alt (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))>
#<alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))>
#<alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))))>
#<alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow im 6) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2))))))) (* (log (/ 1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))))>
#<alt (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))>
#<alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))>
#<alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))))>
#<alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow im 6) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2))))))) (* (log (/ -1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))))>
#<alt (* 1/2 (/ (log (pow re 2)) (log 10)))>
#<alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))>
#<alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 im)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))>
#<alt (* 1/2 (/ (log (pow im 2)) (log 10)))>
#<alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))>
#<alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))>
#<alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ 1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (* -1 (/ (log (/ -1 re)) (log 10)))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))>
#<alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))>
#<alt (* 1/2 (log (pow re 2)))>
#<alt (+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* 1/2 (log (pow im 2)))>
#<alt (+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (* -1 (log (/ 1 re)))>
#<alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (log (/ -1 re)))>
#<alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt re>
#<alt (+ re (* -1 im))>
#<alt (+ re (* im (- (* 2 (/ im re)) 1)))>
#<alt (+ re (* im (- (* im (+ (* -2 (/ im (pow re 2))) (* 2 (/ 1 re)))) 1)))>
#<alt im>
#<alt (* im (+ 1 (* -1 (/ re im))))>
#<alt (* im (- (+ 1 (/ (pow re 2) (pow im 2))) (+ (* -1 (/ (pow re 2) (pow im 2))) (/ re im))))>
#<alt (* im (- (+ 1 (+ (* -1 (/ (* re (- (pow re 2) (* -1 (pow re 2)))) (pow im 3))) (/ (pow re 2) (pow im 2)))) (+ (* -1 (/ (pow re 2) (pow im 2))) (/ re im))))>
#<alt im>
#<alt (* -1 (* im (- (/ re im) 1)))>
#<alt (* -1 (* im (- (* -1 (/ (- (* -1 (/ (- (* -1 (pow re 2)) (pow re 2)) im)) re) im)) 1)))>
#<alt (* -1 (* im (- (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* re (- (* -1 (pow re 2)) (pow re 2))) im)) (* -1 (pow re 2))) (pow re 2)) im)) re) im)) 1)))>
#<alt im>
#<alt (+ im (* -1 re))>
#<alt (+ im (* re (- (* 2 (/ re im)) 1)))>
#<alt (+ im (* re (- (* re (+ (* -2 (/ re (pow im 2))) (* 2 (/ 1 im)))) 1)))>
#<alt re>
#<alt (* re (+ 1 (* -1 (/ im re))))>
#<alt (* re (- (+ 1 (/ (pow im 2) (pow re 2))) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re))))>
#<alt (* re (- (+ 1 (+ (* -1 (/ (* im (- (pow im 2) (* -1 (pow im 2)))) (pow re 3))) (/ (pow im 2) (pow re 2)))) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re))))>
#<alt re>
#<alt (* -1 (* re (- (/ im re) 1)))>
#<alt (* -1 (* re (- (* -1 (/ (- (* -1 (/ (- (* -1 (pow im 2)) (pow im 2)) re)) im) re)) 1)))>
#<alt (* -1 (* re (- (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* im (- (* -1 (pow im 2)) (pow im 2))) re)) (* -1 (pow im 2))) (pow im 2)) re)) im) re)) 1)))>
#<alt (sqrt im)>
#<alt (+ (sqrt im) (* 1/2 (* (sqrt (/ 1 im)) re)))>
#<alt (+ (sqrt im) (* re (+ (* -1/8 (* (sqrt (/ 1 (pow im 3))) re)) (* 1/2 (sqrt (/ 1 im))))))>
#<alt (+ (sqrt im) (* re (+ (* 1/2 (sqrt (/ 1 im))) (* re (+ (* -1/8 (sqrt (/ 1 (pow im 3)))) (* 1/16 (* (sqrt (/ 1 (pow im 5))) re)))))))>
#<alt (sqrt re)>
#<alt (* re (+ (sqrt (/ 1 re)) (* 1/2 (* im (sqrt (/ 1 (pow re 3)))))))>
#<alt (* re (+ (sqrt (/ 1 re)) (+ (* -1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* im (sqrt (/ 1 (pow re 3))))))))>
#<alt (* re (+ (sqrt (/ 1 re)) (+ (* -1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (pow im 3) (sqrt (/ 1 (pow re 7))))) (* 1/2 (* im (sqrt (/ 1 (pow re 3)))))))))>
#<alt (* -1 (* (sqrt re) (pow (sqrt -1) 2)))>
#<alt (* -1 (* re (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))>
#<alt (* -1 (* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2))))))>
#<alt (* -1 (* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (/ (pow im 3) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))))>
#<alt (sqrt re)>
#<alt (+ (sqrt re) (* 1/2 (* im (sqrt (/ 1 re)))))>
#<alt (+ (sqrt re) (* im (+ (* -1/8 (* im (sqrt (/ 1 (pow re 3))))) (* 1/2 (sqrt (/ 1 re))))))>
#<alt (+ (sqrt re) (* im (+ (* 1/2 (sqrt (/ 1 re))) (* im (+ (* -1/8 (sqrt (/ 1 (pow re 3)))) (* 1/16 (* im (sqrt (/ 1 (pow re 5))))))))))>
#<alt (sqrt im)>
#<alt (* im (+ (sqrt (/ 1 im)) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re))))>
#<alt (* im (+ (sqrt (/ 1 im)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)))))>
#<alt (* im (+ (sqrt (/ 1 im)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re))))))>
#<alt (* -1 (* (sqrt im) (pow (sqrt -1) 2)))>
#<alt (* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))>
#<alt (* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))>
#<alt (* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (/ (pow re 3) (pow (sqrt -1) 4)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))))>
#<alt (log (pow re 2))>
#<alt (+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))>
#<alt (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))>
#<alt (+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))>
#<alt (* -2 (log (/ 1 im)))>
#<alt (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))>
#<alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))>
#<alt (* -2 (log (/ -1 im)))>
#<alt (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))>
#<alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))>
#<alt (log (pow im 2))>
#<alt (+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))>
#<alt (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))>
#<alt (+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))>
#<alt (* -2 (log (/ 1 re)))>
#<alt (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))>
#<alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))>
#<alt (* -2 (log (/ -1 re)))>
#<alt (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))>
#<alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))>

Calls

114 calls:

Time	Variable		Point	Expression
45.0ms	im	@	0	(/ (log im) (log 10))
22.0ms	im	@	-inf	(pow (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) 1/2)
13.0ms	im	@	-inf	(/ (log im) (log 10))
6.0ms	im	@	inf	(/ (log im) (log 10))
3.0ms	re	@	inf	(pow (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) 1/2)

rewrite424.0ms (4.5%)

Memory

16.4MiB live, 687.0MiB allocated

Algorithm

1×	batch-egg-rewrite

Rules

7 598×	`lower-fma.f32`
7 594×	`lower-fma.f64`
5 666×	`lower-*.f32`
5 658×	`lower-*.f64`
3 216×	`lower-/.f32`

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	30	193
0	58	131
1	183	126
2	1134	126
0	8665	126

Stop Event

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

Counts

21 → 1 044

Calls

Call 1

Inputs
(hypot.f64 re im)
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (hypot.f64 re im))
(log.f64 #s(literal 10 binary64))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(log.f64 im)
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(/.f64 (log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))
(.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))
(pow.f64 (pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
(/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))
(sqrt.f64 (+.f64 re im))
(log.f64 (fma.f64 im im (*.f64 re re)))

Outputs
(exp.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))
(hypot.f64 re im)
(hypot.f64 im re)
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(/.f64 (sqrt.f64 (+.f64 re im)) (sqrt.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))) (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re))) (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (+.f64 re im)) (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))
(/.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))))
(/.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re))) (-.f64 re im))))
(/.f64 (sqrt.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (sqrt.f64 (.f64 (/.f64 (+.f64 re im) (fma.f64 im im (.f64 re re))) (fma.f64 im (-.f64 im re) (.f64 re re)))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (sqrt.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (sqrt.f64 (neg.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))))))
(/.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (-.f64 re im))) (sqrt.f64 (-.f64 re im)))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (sqrt.f64 (.f64 (+.f64 re im) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(/.f64 (sqrt.f64 (.f64 (neg.f64 (fma.f64 im im (.f64 re re))) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (sqrt.f64 (.f64 (-.f64 (neg.f64 im) re) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(/.f64 (sqrt.f64 (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (sqrt.f64 (fma.f64 im (-.f64 im re) (.f64 re re))))
(/.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (sqrt.f64 (-.f64 (neg.f64 im) re)))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (neg.f64 (sqrt.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (neg.f64 (sqrt.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))))))
(/.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (neg.f64 (sqrt.f64 (+.f64 re im))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (.f64 (fma.f64 im im (.f64 re re)) (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(pow.f64 (exp.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/2 binary64))
(.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) #s(literal 1 binary64))
(.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))
(.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(.f64 (sqrt.f64 (+.f64 re im)) (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im))))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re)))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im)))))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re))))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im)))))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re))))))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(.f64 (pow.f64 (+.f64 re im) #s(literal 1/4 binary64)) (.f64 (pow.f64 (+.f64 re im) #s(literal 1/4 binary64)) (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))))
(.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(.f64 (pow.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) #s(literal 1/4 binary64)) (.f64 (pow.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) #s(literal 1/4 binary64)) (sqrt.f64 (+.f64 re im))))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(.f64 (/.f64 (sqrt.f64 (+.f64 re im)) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))) (/.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))))
(.f64 (/.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))) (/.f64 (sqrt.f64 (+.f64 re im)) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))))
(.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64)))
(.f64 (.f64 (sqrt.f64 (+.f64 re im)) (pow.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) #s(literal 1/4 binary64))) (pow.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) #s(literal 1/4 binary64)))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))))
(+.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(+.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (log.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(exp.f64 (.f64 (log.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(exp.f64 (.f64 (log.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) #s(literal 1/2 binary64)))
(fabs.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 #s(literal 0 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(sqrt.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(fma.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))))
(neg.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (.f64 #s(literal 1 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re)))))
(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64))))
(/.f64 (exp.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (exp.f64 (log.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)))) (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) #s(literal 2 binary64))
(pow.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) #s(literal 4 binary64))
(pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) #s(literal 1/2 binary64))
(pow.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) (*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(.f64 #s(literal 1 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal -1/2 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)))
(.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) #s(literal 1 binary64)))
(.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(.f64 #s(literal -1 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))))
(.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1/4 binary64)) (.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))))
(.f64 (sqrt.f64 #s(literal 1/2 binary64)) (.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)) (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (pow.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(.f64 (pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) #s(literal 1 binary64)) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (pow.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(.f64 (pow.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(.f64 (exp.f64 (log.f64 #s(literal 1/2 binary64))) (exp.f64 (log.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))))))
(.f64 (exp.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (exp.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64))))))
(.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (/.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
(.f64 (.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 (.f64 #s(literal 1 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 #s(literal 1 binary64) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)))
(.f64 (.f64 #s(literal 1 binary64) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/2 binary64))
(.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (pow.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)))
(.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1/4 binary64))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)))
(.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(log.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (neg.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 re im)))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))))
(+.f64 (log.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64))) (log.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64))))
(exp.f64 (.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1 binary64)))
(-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))))
(-.f64 #s(literal 0 binary64) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)))
(-.f64 (log.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (sqrt.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))))
(-.f64 (log.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (sqrt.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))))))
(-.f64 (log.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(-.f64 (/.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))) (/.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 2 binary64)) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (neg.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 re im)))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))
(fma.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 1/2 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(fma.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 1/2 binary64) (neg.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 re im)))))
(fma.f64 (log.f64 (+.f64 re im)) #s(literal 1/2 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))
(neg.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 3 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))))))
(/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))))))))
(/.f64 (neg.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))))) (neg.f64 (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (+.f64 re im)) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))))))
(/.f64 (-.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 2 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))))
(pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1 binary64))
(.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
(.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
(.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 #s(literal -1/2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))
(.f64 #s(literal -1 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)))
(.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1/2 binary64))
(.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))))))
(.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))))
(.f64 (pow.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1 binary64)) #s(literal 1/2 binary64))
(log.f64 #s(literal 10 binary64))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(.f64 (.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(log.f64 im)
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 im)))
(neg.f64 (neg.f64 (log.f64 im)))
(*.f64 (log.f64 im) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 im))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)))))
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))))
(/.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) #s(literal -1 binary64))
(.f64 (log.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64))))
(.f64 (neg.f64 (log.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) #s(literal -1 binary64)))
(.f64 #s(literal -1 binary64) (/.f64 (log.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 1/10 binary64))))
(.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) #s(literal -1/2 binary64)))
(.f64 (.f64 #s(literal 1 binary64) (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(+.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64)))))))
(+.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (neg.f64 (log.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64)))))))
(+.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))) (log.f64 (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))))
(+.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))) (neg.f64 (log.f64 (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))))
(-.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (log.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))))))
(-.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (log.f64 (fma.f64 im im (.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)))))
(-.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))) (log.f64 (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))))
(-.f64 (log.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im))))) (log.f64 (neg.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64)))))))
(-.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (+.f64 (/.f64 (.f64 re (.f64 re #s(literal -1/2 binary64))) im) im))) (log.f64 (+.f64 (/.f64 (.f64 re (.f64 re #s(literal -1/2 binary64))) im) im)))
(-.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))))) (log.f64 (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))))))
(neg.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))))) #s(literal 3 binary64))) (fma.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (log.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (fma.f64 (log.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))))) (log.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))))) (.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (log.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (*.f64 im #s(literal 2 binary64)))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) #s(literal 3 binary64))) (fma.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))) (log.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))) (fma.f64 (log.f64 (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (log.f64 (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))) (log.f64 (-.f64 (.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))))))
(/.f64 (-.f64 (.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (log.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im))))) (.f64 (log.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))))) (log.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))))))) (+.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (log.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64)))))))
(/.f64 (-.f64 (.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))) (log.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)))) (.f64 (log.f64 (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (log.f64 (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)))) (+.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))) (log.f64 (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))))
(.f64 (log.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #s(literal 1 binary64))
(.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)))
(.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))))
(+.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))))
(+.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)
(+.f64 (/.f64 (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (neg.f64 (/.f64 (.f64 im im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))))
(-.f64 (/.f64 (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)))
(-.f64 (/.f64 (.f64 im im) (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))))) (/.f64 (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))) (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))))))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(fma.f64 im #s(literal 1 binary64) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))))
(fma.f64 #s(literal 1/2 binary64) (.f64 (/.f64 #s(literal 1 binary64) im) (.f64 re re)) im)
(fma.f64 #s(literal 1/2 binary64) (.f64 (.f64 (/.f64 #s(literal 1 binary64) im) re) re) im)
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(fma.f64 (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) re im)
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(fma.f64 #s(literal 1 binary64) im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))))
(fma.f64 #s(literal 1 binary64) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)
(fma.f64 #s(literal -1/2 binary64) (.f64 (/.f64 #s(literal -1 binary64) im) (.f64 re re)) im)
(fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (neg.f64 (/.f64 (.f64 im im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))))
(fma.f64 (/.f64 #s(literal 1 binary64) im) (.f64 #s(literal 1/2 binary64) (.f64 re re)) im)
(fma.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 (/.f64 #s(literal 1 binary64) im) re) im)
(fma.f64 #s(literal -1 binary64) (neg.f64 im) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))))
(fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (.f64 re (.f64 re #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) im) im)
(fma.f64 (/.f64 re im) (/.f64 re #s(literal 2 binary64)) im)
(fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im)
(fma.f64 (/.f64 (*.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) im) im)
(fma.f64 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 im #s(literal 1/2 binary64)) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))))
(fma.f64 (.f64 (.f64 re re) (/.f64 #s(literal 1 binary64) im)) #s(literal 1/2 binary64) im)
(fma.f64 (.f64 (.f64 #s(literal 1/2 binary64) (*.f64 re re)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) im) im)
(neg.f64 (/.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im))) (neg.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64)))))))
(neg.f64 (/.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (+.f64 (/.f64 (.f64 re (.f64 re #s(literal -1/2 binary64))) im) im)))
(neg.f64 (/.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))))))
(neg.f64 (/.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (+.f64 (/.f64 (.f64 re (.f64 re #s(literal -1/2 binary64))) im) im)) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im im (.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))) (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))))))
(/.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im))) (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64)))))
(/.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im))) (fma.f64 im im (.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))))
(/.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))))
(/.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (neg.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))))))
(/.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (neg.f64 (fma.f64 im im (.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)))))
(/.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (+.f64 (/.f64 (.f64 re (.f64 re #s(literal -1/2 binary64))) im) im)) (+.f64 (/.f64 (.f64 re (.f64 re #s(literal -1/2 binary64))) im) im))
(/.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))))) (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (.f64 (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im) (.f64 im im))) (.f64 (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im) (-.f64 (.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im))))) (neg.f64 (neg.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64)))))))
(/.f64 (neg.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (+.f64 (/.f64 (.f64 re (.f64 re #s(literal -1/2 binary64))) im) im))) (neg.f64 (+.f64 (/.f64 (.f64 re (.f64 re #s(literal -1/2 binary64))) im) im)))
(/.f64 (neg.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))))) (neg.f64 (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (.f64 im im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) #s(literal 3 binary64))) (fma.f64 (/.f64 (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (/.f64 (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (fma.f64 (/.f64 (.f64 im im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (.f64 (/.f64 (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))))))
(/.f64 (-.f64 (.f64 (/.f64 (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (/.f64 (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))) (.f64 (/.f64 (.f64 im im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)))) (+.f64 (/.f64 (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64))) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) #s(literal -1 binary64))
(.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (.f64 (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im))) im))))
(.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (*.f64 im #s(literal 2 binary64))))))
(.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 im im (.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) (-.f64 (.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)))))
(.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (.f64 im #s(literal 2 binary64)))) (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (*.f64 im #s(literal 2 binary64)))))))
(.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im))) im)))
(.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 (.f64 (.f64 re re) (.f64 re re)) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im)))) (.f64 im (.f64 im im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 im (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (.f64 (.f64 re re) (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)))) (*.f64 im #s(literal 2 binary64)))))))
(.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (+.f64 (/.f64 (.f64 re (.f64 re #s(literal -1/2 binary64))) im) im)) (/.f64 #s(literal 1 binary64) (+.f64 (/.f64 (.f64 re (*.f64 re #s(literal -1/2 binary64))) im) im)))
(.f64 (.f64 (fma.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im)) im) (-.f64 im (.f64 re (.f64 re (/.f64 #s(literal 1/2 binary64) im))))) (/.f64 #s(literal 1 binary64) (-.f64 im (.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im))))))
(neg.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) im) re))
(neg.f64 (*.f64 re (/.f64 #s(literal -1/2 binary64) im)))
(neg.f64 (/.f64 (*.f64 re #s(literal 1/2 binary64)) (neg.f64 im)))
(neg.f64 (/.f64 (*.f64 re #s(literal -1/2 binary64)) im))
(/.f64 re (*.f64 im #s(literal 2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 im (*.f64 re #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 im #s(literal 2 binary64)) re))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64)))))
(/.f64 (*.f64 re #s(literal -1/2 binary64)) (neg.f64 im))
(/.f64 (neg.f64 re) (*.f64 im #s(literal -2 binary64)))
(/.f64 (neg.f64 (*.f64 re #s(literal -1/2 binary64))) im)
(pow.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal -1 binary64))
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(.f64 #s(literal 1/2 binary64) (.f64 (/.f64 #s(literal 1 binary64) im) re))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(.f64 #s(literal 1/2 binary64) (.f64 re (/.f64 #s(literal 1 binary64) im)))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) re)
(.f64 #s(literal 1 binary64) (.f64 re (/.f64 #s(literal 1/2 binary64) im)))
(.f64 #s(literal -1/2 binary64) (.f64 (/.f64 #s(literal -1 binary64) im) re))
(.f64 (/.f64 #s(literal 1 binary64) im) (.f64 re #s(literal 1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 re #s(literal 2 binary64)))
(.f64 (.f64 re #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) im))
(.f64 (.f64 re #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) im))
(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
(*.f64 (/.f64 re #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) im))
(.f64 (.f64 re (/.f64 #s(literal 1 binary64) im)) #s(literal 1/2 binary64))
(.f64 (.f64 (*.f64 re #s(literal 1/2 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) im))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))))
(+.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(+.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (log.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(exp.f64 (.f64 (log.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(exp.f64 (.f64 (log.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) #s(literal 1/2 binary64)))
(fabs.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 #s(literal 0 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(sqrt.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(fma.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))))
(neg.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (.f64 #s(literal 1 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re)))))
(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64))))
(/.f64 (exp.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (exp.f64 (log.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)))) (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) #s(literal 2 binary64))
(pow.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) #s(literal 4 binary64))
(pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) #s(literal 1/2 binary64))
(pow.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) (*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(.f64 #s(literal 1 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal -1/2 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)))
(.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) #s(literal 1 binary64)))
(.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(.f64 #s(literal -1 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))))
(.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1/4 binary64)) (.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))))
(.f64 (sqrt.f64 #s(literal 1/2 binary64)) (.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)) (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (pow.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(.f64 (pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) #s(literal 1 binary64)) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (pow.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(.f64 (pow.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(.f64 (exp.f64 (log.f64 #s(literal 1/2 binary64))) (exp.f64 (log.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))))))
(.f64 (exp.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (exp.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64))))))
(.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (/.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
(.f64 (.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 (.f64 #s(literal 1 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 #s(literal 1 binary64) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)))
(.f64 (.f64 #s(literal 1 binary64) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/2 binary64))
(.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (pow.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)))
(.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1/4 binary64))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)))
(.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(log.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (neg.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 re im)))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))))
(+.f64 (log.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64))) (log.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64))))
(exp.f64 (.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1 binary64)))
(-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))))
(-.f64 #s(literal 0 binary64) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)))
(-.f64 (log.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (sqrt.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))))
(-.f64 (log.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (sqrt.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))))))
(-.f64 (log.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(-.f64 (/.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))) (/.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 2 binary64)) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (neg.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 re im)))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))
(fma.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 1/2 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(fma.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 1/2 binary64) (neg.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 re im)))))
(fma.f64 (log.f64 (+.f64 re im)) #s(literal 1/2 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))
(neg.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 3 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))))))
(/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))))))))
(/.f64 (neg.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))))) (neg.f64 (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (+.f64 re im)) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))))))
(/.f64 (-.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 2 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))))
(pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1 binary64))
(.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
(.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
(.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 #s(literal -1/2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))
(.f64 #s(literal -1 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)))
(.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1/2 binary64))
(.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))))))
(.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))))
(.f64 (pow.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1 binary64)) #s(literal 1/2 binary64))
(exp.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))
(hypot.f64 re im)
(hypot.f64 im re)
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(/.f64 (sqrt.f64 (+.f64 re im)) (sqrt.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))) (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re))) (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (+.f64 re im)) (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))
(/.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))))
(/.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re))) (-.f64 re im))))
(/.f64 (sqrt.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (sqrt.f64 (.f64 (/.f64 (+.f64 re im) (fma.f64 im im (.f64 re re))) (fma.f64 im (-.f64 im re) (.f64 re re)))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (sqrt.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (sqrt.f64 (neg.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))))))
(/.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (-.f64 re im))) (sqrt.f64 (-.f64 re im)))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (sqrt.f64 (.f64 (+.f64 re im) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(/.f64 (sqrt.f64 (.f64 (neg.f64 (fma.f64 im im (.f64 re re))) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (sqrt.f64 (.f64 (-.f64 (neg.f64 im) re) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(/.f64 (sqrt.f64 (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (sqrt.f64 (fma.f64 im (-.f64 im re) (.f64 re re))))
(/.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (sqrt.f64 (-.f64 (neg.f64 im) re)))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (neg.f64 (sqrt.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (neg.f64 (sqrt.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))))))
(/.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (neg.f64 (sqrt.f64 (+.f64 re im))))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (.f64 (fma.f64 im im (.f64 re re)) (fma.f64 im im (*.f64 re re))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(pow.f64 (exp.f64 (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/2 binary64))
(.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) #s(literal 1 binary64))
(.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (*.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))
(.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))
(.f64 (sqrt.f64 (+.f64 re im)) (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im))))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re)))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im)))))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re))))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im)))))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re))))))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(.f64 (pow.f64 (+.f64 re im) #s(literal 1/4 binary64)) (.f64 (pow.f64 (+.f64 re im) #s(literal 1/4 binary64)) (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))))
(.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)))
(.f64 (pow.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) #s(literal 1/4 binary64)) (.f64 (pow.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) #s(literal 1/4 binary64)) (sqrt.f64 (+.f64 re im))))
(.f64 (sqrt.f64 (.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(.f64 (/.f64 (sqrt.f64 (+.f64 re im)) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))) (/.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))))
(.f64 (/.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))) (/.f64 (sqrt.f64 (+.f64 re im)) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))))
(.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64)))
(.f64 (.f64 (sqrt.f64 (+.f64 re im)) (pow.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) #s(literal 1/4 binary64))) (pow.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) #s(literal 1/4 binary64)))
(exp.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))
(sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))
(neg.f64 (/.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (neg.f64 (sqrt.f64 (+.f64 re im)))))
(neg.f64 (/.f64 (neg.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (+.f64 re im))))
(/.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) (sqrt.f64 (+.f64 re im)))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (sqrt.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re))))))
(/.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (.f64 (+.f64 re im) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im)))))))
(/.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (.f64 (+.f64 re im) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re))))))
(/.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im)))) (+.f64 re im))))
(/.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re))) (+.f64 re im))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (.f64 (*.f64 (+.f64 re im) (+.f64 re im)) (-.f64 im re))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (+.f64 re im))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (.f64 (+.f64 re im) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (.f64 (+.f64 re im) (*.f64 (-.f64 re im) (+.f64 re im)))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 im im (*.f64 re re)))) (sqrt.f64 (-.f64 (neg.f64 im) re)))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (neg.f64 (sqrt.f64 (+.f64 re im))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (+.f64 re im) (neg.f64 (fma.f64 im im (*.f64 re re))))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (-.f64 re im))) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (+.f64 re im))) (sqrt.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))))
(/.f64 (sqrt.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (+.f64 re im))) (sqrt.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))))
(/.f64 (sqrt.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (sqrt.f64 (-.f64 (neg.f64 im) re))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))) (neg.f64 (neg.f64 (sqrt.f64 (+.f64 re im)))))
(pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) #s(literal 1/2 binary64))
(pow.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))
(pow.f64 (sqrt.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))) #s(literal 1/2 binary64))
(.f64 (sqrt.f64 (fma.f64 im im (.f64 re re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (*.f64 (sqrt.f64 (+.f64 re im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)))))
(.f64 (sqrt.f64 (+.f64 re im)) (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)))))
(.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))
(.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im))) (sqrt.f64 (fma.f64 im im (.f64 re re))))
(.f64 (sqrt.f64 (neg.f64 (fma.f64 im im (.f64 re re)))) (pow.f64 (/.f64 #s(literal -1 binary64) (+.f64 re im)) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (neg.f64 (fma.f64 im im (.f64 re re)))) (sqrt.f64 (/.f64 #s(literal -1 binary64) (+.f64 re im))))
(.f64 (sqrt.f64 (neg.f64 (fma.f64 im im (.f64 re re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (-.f64 (neg.f64 im) re))))
(.f64 (neg.f64 (sqrt.f64 (fma.f64 im im (.f64 re re)))) (/.f64 #s(literal 1 binary64) (neg.f64 (sqrt.f64 (+.f64 re im)))))
(.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64)) (.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)))))
(.f64 (pow.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) #s(literal 1/4 binary64)) (pow.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) #s(literal 1/4 binary64)))
(.f64 (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))
(.f64 (pow.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 im (-.f64 im re) (.f64 re re))))
(.f64 (pow.f64 (/.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/2 binary64)) (sqrt.f64 (-.f64 re im)))
(.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (sqrt.f64 (fma.f64 im (-.f64 im re) (.f64 re re))))
(.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (-.f64 re im)))
(.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))) (/.f64 (sqrt.f64 (+.f64 re im)) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))))
(.f64 (/.f64 (sqrt.f64 (+.f64 re im)) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))) (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))))
(.f64 (/.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))) (/.f64 (pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/4 binary64)) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64))))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))))
(+.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(+.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (log.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(exp.f64 (.f64 (log.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(exp.f64 (.f64 (log.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) #s(literal 1/2 binary64)))
(fabs.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 #s(literal 0 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(sqrt.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(fma.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))))
(neg.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (.f64 #s(literal 1 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re)))))
(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64))))
(/.f64 (exp.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (exp.f64 (log.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)))) (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) #s(literal 2 binary64))
(pow.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) #s(literal 4 binary64))
(pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) #s(literal 1/2 binary64))
(pow.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) (*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(.f64 #s(literal 1 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal -1/2 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)))
(.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) #s(literal 1 binary64)))
(.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(.f64 #s(literal -1 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))))
(.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1/4 binary64)) (.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))))
(.f64 (sqrt.f64 #s(literal 1/2 binary64)) (.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)) (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (pow.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(.f64 (pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) #s(literal 1 binary64)) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (pow.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(.f64 (pow.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(.f64 (exp.f64 (log.f64 #s(literal 1/2 binary64))) (exp.f64 (log.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))))))
(.f64 (exp.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (exp.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64))))))
(.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (/.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
(.f64 (.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 (.f64 #s(literal 1 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 #s(literal 1 binary64) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)))
(.f64 (.f64 #s(literal 1 binary64) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/2 binary64))
(.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (pow.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)))
(.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1/4 binary64))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)))
(.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)))
(exp.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(exp.f64 (.f64 (log.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) #s(literal 1/4 binary64)))
(exp.f64 (.f64 (.f64 (log.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(fabs.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re))))) #s(literal 1 binary64)))
(/.f64 #s(literal -1 binary64) (neg.f64 (sqrt.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re)))))))
(/.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (sqrt.f64 (log.f64 #s(literal 10 binary64))))
(/.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64))) (sqrt.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)))))
(/.f64 (neg.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (neg.f64 (sqrt.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (neg.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)))) (neg.f64 (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))
(pow.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) #s(literal 1 binary64))
(pow.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1/2 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) #s(literal 1/4 binary64))
(pow.f64 (sqrt.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re))))) #s(literal -1 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(.f64 #s(literal 1 binary64) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))))
(.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1/4 binary64)) (.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))))
(.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64)))))
(.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (log.f64 #s(literal 1/10 binary64)))))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)) (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))))
(.f64 (pow.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(.f64 (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(.f64 (pow.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) #s(literal 1/2 binary64)) (pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) #s(literal 1/2 binary64)))
(.f64 (pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) #s(literal 1/2 binary64)) (pow.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) #s(literal 1/2 binary64)))
(.f64 (pow.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64)))
(.f64 (pow.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1 binary64)) (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64)))
(.f64 (pow.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)) #s(literal 2 binary64)))
(.f64 (pow.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(.f64 (sqrt.f64 (log.f64 (fma.f64 im im (.f64 re re)))) (sqrt.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 (sqrt.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))) (sqrt.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))))
(.f64 (sqrt.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))) (sqrt.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))))
(.f64 (.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)))
(.f64 (.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (pow.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)))
(.f64 (.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1/4 binary64))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))))
(+.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(+.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (log.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(exp.f64 (.f64 (log.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(exp.f64 (.f64 (log.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) #s(literal 1/2 binary64)))
(fabs.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 #s(literal 0 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(sqrt.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(fma.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))))
(neg.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (.f64 #s(literal 1 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re)))))
(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64))))
(/.f64 (exp.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(/.f64 (exp.f64 (log.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)))) (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64))
(pow.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) #s(literal 2 binary64))
(pow.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1 binary64))
(pow.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) #s(literal 4 binary64))
(pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) #s(literal 1/2 binary64))
(pow.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) (*.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))
(.f64 #s(literal 1 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal -1/2 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal -1 binary64)))
(.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)))
(.f64 (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))) (pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) #s(literal 1 binary64)))
(.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(.f64 #s(literal -1 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (log.f64 #s(literal 1/10 binary64))))
(.f64 (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64)) (.f64 (pow.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))))
(.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1/4 binary64)) (.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))))
(.f64 (sqrt.f64 #s(literal 1/2 binary64)) (.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) (*.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)) (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (pow.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(.f64 (pow.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) #s(literal 1 binary64)) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (pow.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(.f64 (pow.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(.f64 (exp.f64 (log.f64 #s(literal 1/2 binary64))) (exp.f64 (log.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))))))
(.f64 (exp.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) (exp.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64))))))
(.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (/.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 #s(literal 1/2 binary64))) (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64)))))
(.f64 (.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 (.f64 #s(literal 1 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 #s(literal 1 binary64) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (.f64 #s(literal 1 binary64) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)))
(.f64 (.f64 #s(literal 1 binary64) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64))) (sqrt.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1/2 binary64))
(.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (pow.f64 #s(literal 1/2 binary64) #s(literal 1/4 binary64))) (pow.f64 (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64)))
(.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1/4 binary64))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)))
(.f64 (.f64 (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3/4 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64))) (pow.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 1/8 binary64)))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(log.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im im (*.f64 re re))))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (neg.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 re im)))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))))
(+.f64 (log.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64))) (log.f64 (pow.f64 (fma.f64 im im (.f64 re re)) #s(literal 1/4 binary64))))
(exp.f64 (.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))) #s(literal 1 binary64)))
(-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)))))
(-.f64 #s(literal 0 binary64) (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)))
(-.f64 (log.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (sqrt.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))))
(-.f64 (log.f64 (sqrt.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (sqrt.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))))))
(-.f64 (log.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (sqrt.f64 (.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(-.f64 (/.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))) (/.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 2 binary64)) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (neg.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 re im)))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im)) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))
(fma.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 1/2 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(fma.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 1/2 binary64) (neg.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (+.f64 re im)))))
(fma.f64 (log.f64 (+.f64 re im)) #s(literal 1/2 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))
(neg.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal -1/2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))))) (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 3 binary64)) (pow.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))))))
(/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))))
(/.f64 (neg.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))))))))
(/.f64 (neg.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))))) (neg.f64 (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))))
(/.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (+.f64 re im)) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))))))
(/.f64 (-.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 2 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))))
(pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal 1 binary64))
(.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))) #s(literal 1 binary64))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
(.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64)))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
(.f64 #s(literal 1 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 #s(literal -1/2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))
(.f64 #s(literal -1 binary64) (.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal -1/2 binary64)))
(.f64 (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (sqrt.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))))
(.f64 (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))) #s(literal -1/2 binary64))
(.f64 (fma.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) #s(literal 2 binary64)) (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))))))
(.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im))))))
(.f64 (pow.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1 binary64)) #s(literal 1/2 binary64))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 re re)) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 im im)))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 im im)) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 re re)))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) re)) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) im)))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) im)) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) re)))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 re (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 im (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))
(+.f64 (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 im (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 re (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))
(+.f64 (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (.f64 re re)) (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (.f64 im (-.f64 im re))))
(+.f64 (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (.f64 im (-.f64 im re))) (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (.f64 re re)))
(+.f64 (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) re) (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 im)))
(+.f64 (.f64 (.f64 re re) (/.f64 #s(literal 1 binary64) (+.f64 re im))) (.f64 (.f64 im im) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(+.f64 (.f64 (.f64 im im) (/.f64 #s(literal 1 binary64) (+.f64 re im))) (.f64 (.f64 re re) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(+.f64 (.f64 (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) re) (/.f64 #s(literal 1 binary64) (+.f64 re im))) (.f64 (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) im) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(+.f64 (.f64 (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) im) (/.f64 #s(literal 1 binary64) (+.f64 re im))) (.f64 (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) re) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(+.f64 (.f64 (.f64 re (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (/.f64 #s(literal 1 binary64) (+.f64 re im))) (.f64 (.f64 im (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(+.f64 (.f64 (.f64 im (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (/.f64 #s(literal 1 binary64) (+.f64 re im))) (.f64 (.f64 re (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(+.f64 (.f64 (.f64 re re) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (.f64 (.f64 im (-.f64 im re)) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))))
(+.f64 (.f64 (.f64 im (-.f64 im re)) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (.f64 (.f64 re re) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))))
(+.f64 (.f64 re (/.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (.f64 (neg.f64 im) (/.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))))
(exp.f64 (.f64 (log.f64 (/.f64 (+.f64 re im) (fma.f64 im im (.f64 re re)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (neg.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))
(-.f64 (/.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)) (/.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)))
(-.f64 (/.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im)) (/.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im)))
(-.f64 (/.f64 #s(literal 0 binary64) (-.f64 (neg.f64 im) re)) (neg.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))
(-.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (.f64 (+.f64 re im) (+.f64 re im)) (-.f64 im re))) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (+.f64 re im) (+.f64 re im)) (-.f64 im re))))
(-.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (+.f64 re im) (.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 re (/.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (neg.f64 im) (/.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (.f64 re re) (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (*.f64 im im) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(fma.f64 (.f64 re re) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (.f64 (.f64 im (-.f64 im re)) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (*.f64 im im))))))
(fma.f64 (.f64 im im) (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (*.f64 re re) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(fma.f64 (.f64 im (-.f64 im re)) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (.f64 (.f64 re re) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (*.f64 im im))))))
(fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 re re) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (*.f64 im im)))
(fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 im im) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (*.f64 re re)))
(fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) re) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) im)))
(fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) im) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) re)))
(fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 re (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 im (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))))
(fma.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 im (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 re (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)))))
(fma.f64 (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) re) (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) im) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(fma.f64 (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) im) (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) re) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(fma.f64 (.f64 re (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (.f64 im (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(fma.f64 (.f64 im (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (.f64 re (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(fma.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (.f64 re re) (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (*.f64 im (-.f64 im re))))
(fma.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (.f64 im (-.f64 im re)) (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (*.f64 re re)))
(fma.f64 (/.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) re (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (neg.f64 im)))
(neg.f64 (neg.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))
(neg.f64 (.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))))
(neg.f64 (/.f64 #s(literal -1 binary64) (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re)))))
(/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 re im) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 re im) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))) (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (+.f64 re im) (+.f64 re im)) (-.f64 im re)) (.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 re im) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))) (+.f64 re im)) (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))) (+.f64 re im)) (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (*.f64 im im))))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (+.f64 re im)) (.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 re im) (.f64 (-.f64 re im) (+.f64 re im))) (.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))) (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (+.f64 re im))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))) (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (+.f64 re im))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 re im) (-.f64 im re)) (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))))
(/.f64 (neg.f64 (fma.f64 im im (*.f64 re re))) (-.f64 (neg.f64 im) re))
(/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im)))) (+.f64 re im)))
(/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re))) (+.f64 re im)))
(/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (+.f64 re im) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im))))))
(/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (+.f64 re im) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re)))))
(/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (/.f64 #s(literal 1 binary64) (fma.f64 im im (*.f64 re re))))
(/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (+.f64 re im)))
(/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (*.f64 (+.f64 re im) (+.f64 re im)) (-.f64 im re)))
(/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (+.f64 re im) (*.f64 (-.f64 re im) (+.f64 re im))))
(/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (+.f64 re im) (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 #s(literal -1 binary64) (/.f64 (+.f64 re im) (neg.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (neg.f64 (.f64 (+.f64 re im) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im)))))))
(/.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (neg.f64 (.f64 (+.f64 re im) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re))))))
(/.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (neg.f64 (.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im)))) (+.f64 re im))))
(/.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (neg.f64 (.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re))) (+.f64 re im))))
(/.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (.f64 (*.f64 (+.f64 re im) (+.f64 re im)) (-.f64 im re))))
(/.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (.f64 (*.f64 (+.f64 re im) (-.f64 im re)) (+.f64 re im))))
(/.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (.f64 (+.f64 re im) (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (.f64 (+.f64 re im) (*.f64 (-.f64 re im) (+.f64 re im)))))
(/.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (+.f64 re im)) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))
(/.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (+.f64 re im)) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))))
(/.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)) (.f64 (+.f64 re im) (-.f64 im re)))
(/.f64 (.f64 (fma.f64 im im (.f64 re re)) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (-.f64 re im))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (neg.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (+.f64 re im))) (neg.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))))
(/.f64 (neg.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (+.f64 re im))) (neg.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))))
(/.f64 (neg.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (neg.f64 (.f64 (+.f64 re im) (-.f64 im re))))
(pow.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re))) #s(literal -1 binary64))
(.f64 (fma.f64 im im (.f64 re re)) (/.f64 #s(literal 1 binary64) (+.f64 re im)))
(.f64 (fma.f64 im im (.f64 re re)) (/.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (+.f64 re im) (.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) #s(literal 1 binary64))
(.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) (/.f64 (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (+.f64 re im) (-.f64 im re))))
(.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 (+.f64 re im) (-.f64 re im))))
(.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) (*.f64 (+.f64 re im) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))
(.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))
(.f64 (neg.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal -1 binary64) (+.f64 re im)))
(.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))))
(.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))))))
(.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))) (+.f64 re im))))
(.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))) (+.f64 re im))))
(.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (fma.f64 im im (.f64 re re)))
(.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (.f64 (.f64 (+.f64 re im) (+.f64 re im)) (-.f64 im re))))
(.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (+.f64 re im))))
(.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (.f64 (+.f64 re im) (-.f64 re im)))))
(.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (.f64 (-.f64 re im) (+.f64 re im)))))
(.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))))
(.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (-.f64 re im) (fma.f64 im im (.f64 re re))))
(.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (+.f64 re im)) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im))))))
(.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (+.f64 re im)) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re)))))
(.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))))
(.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 im re)))
(.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (.f64 (fma.f64 im (-.f64 im re) (.f64 re re)) (fma.f64 im im (*.f64 re re))))
(.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (fma.f64 im (-.f64 im re) (.f64 re re)))
(.f64 (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (.f64 re re)))))
(.f64 (/.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 re im))
(.f64 (/.f64 (fma.f64 im im (.f64 re re)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (.f64 (fma.f64 im im (.f64 re re)) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))
(.f64 (.f64 (fma.f64 im im (*.f64 re re)) (-.f64 re im)) (/.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (-.f64 re im)))
(.f64 (pow.f64 (/.f64 (+.f64 re im) (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im))))))
(.f64 (pow.f64 (/.f64 (+.f64 re im) (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re)))))
(.f64 (pow.f64 (/.f64 (+.f64 re im) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 im im (.f64 re re)) (-.f64 re im))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))
(.f64 (/.f64 (+.f64 re im) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (/.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (.f64 re re)))))
(.f64 (/.f64 (+.f64 re im) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im)) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (/.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (/.f64 (+.f64 re im) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (.f64 re re)))))
(.f64 (/.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (+.f64 re im) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (/.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (/.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (/.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (/.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(.f64 (/.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))) (+.f64 re im)) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))))
(.f64 (/.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))) (+.f64 re im)) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))))
(.f64 (/.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))) (+.f64 re im)) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))))
(.f64 (/.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))) (+.f64 re im)) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))))
(.f64 (.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 im im (*.f64 re re)))) (/.f64 #s(literal -1 binary64) (+.f64 re im)))
(.f64 (.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (fma.f64 im (-.f64 im re) (*.f64 re re)))
(.f64 (.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (-.f64 re im))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (+.f64 re im))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 im re))))
(exp.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (+.f64 re im))))
(hypot.f64 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 re #s(literal 1/2 binary64)))
(hypot.f64 (pow.f64 re #s(literal 1/2 binary64)) (pow.f64 im #s(literal 1/2 binary64)))
(sqrt.f64 (+.f64 re im))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (-.f64 re im)) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 im (-.f64 im re) (.f64 re re))) (sqrt.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))))
(/.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (sqrt.f64 (-.f64 im re)))
(/.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (-.f64 re im)))
(/.f64 (sqrt.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (sqrt.f64 (fma.f64 im (-.f64 im re) (.f64 re re))))
(/.f64 (sqrt.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (+.f64 (neg.f64 re) im)))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (sqrt.f64 (neg.f64 (fma.f64 im (-.f64 im re) (.f64 re re)))))
(/.f64 (neg.f64 (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (sqrt.f64 (-.f64 re im))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (neg.f64 (sqrt.f64 (fma.f64 im (-.f64 im re) (.f64 re re)))))
(pow.f64 (+.f64 re im) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (+.f64 re im) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (+.f64 re im) (+.f64 re im)) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 (log.f64 (+.f64 re im))) #s(literal 1/2 binary64))
(.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))) (pow.f64 (/.f64 #s(literal 1 binary64) (-.f64 re im)) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (-.f64 re im))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (*.f64 re re))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(*.f64 (pow.f64 (+.f64 re im) #s(literal 1/4 binary64)) (pow.f64 (+.f64 re im) #s(literal 1/4 binary64)))
(log.f64 (fma.f64 im im (*.f64 re re)))
(+.f64 (log.f64 (fma.f64 im im (*.f64 re re))) #s(literal 0 binary64))
(+.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))))
(+.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))))))
(+.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (neg.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))))
(+.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (neg.f64 (log.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))))))
(+.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 im re)))))
(+.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(+.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im)))))
(+.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(+.f64 (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))) (log.f64 (+.f64 re im)))
(+.f64 (log.f64 (+.f64 re im)) (log.f64 (/.f64 (fma.f64 im im (*.f64 re re)) (+.f64 re im))))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
(-.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))))
(-.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))))
(-.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (.f64 (+.f64 re im) (-.f64 im re))))
(-.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 re im))) (log.f64 (.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re))) (-.f64 re im))))
(-.f64 (log.f64 (+.f64 re im)) (log.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re)))))
(-.f64 (log.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (log.f64 (.f64 (/.f64 (+.f64 re im) (fma.f64 im im (.f64 re re))) (fma.f64 im (-.f64 im re) (.f64 re re)))))
(-.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (log.f64 (.f64 (+.f64 re im) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(-.f64 (log.f64 (.f64 (neg.f64 (fma.f64 im im (.f64 re re))) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (log.f64 (.f64 (-.f64 (neg.f64 im) re) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(-.f64 (log.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (neg.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))))
(-.f64 (log.f64 (neg.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (neg.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))))))
(-.f64 (log.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 im (-.f64 im re) (.f64 re re))))
(-.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (log.f64 (+.f64 re im)))
(-.f64 (log.f64 (neg.f64 (.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im)))) (log.f64 (-.f64 (neg.f64 im) re)))
(-.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (-.f64 re im))) (log.f64 (-.f64 re im)))
(fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 (+.f64 re im) (fma.f64 im im (*.f64 re re)))) (log.f64 (+.f64 re im)))
(neg.f64 (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) #s(literal 3 binary64))) (fma.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (fma.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (log.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (*.f64 im im)))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))) #s(literal 3 binary64))) (fma.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (fma.f64 (log.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))) (log.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))) (.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (*.f64 re re))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64))) (fma.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 im re))) (log.f64 (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 re im))) #s(literal 3 binary64))) (fma.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 re im))) (log.f64 (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))))
(/.f64 (-.f64 (.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (.f64 (log.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))) (log.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im))))))) (+.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))))
(/.f64 (-.f64 (.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (.f64 (log.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))) (log.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re)))))) (+.f64 (log.f64 (fma.f64 re (.f64 (.f64 re re) (.f64 re (.f64 re re))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 re re) (.f64 re re))))))
(/.f64 (-.f64 (.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re))))) (.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 im re))) (log.f64 (.f64 (+.f64 re im) (-.f64 im re))))) (+.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (-.f64 (.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))))) (.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 re im))) (log.f64 (.f64 (+.f64 re im) (-.f64 re im))))) (+.f64 (log.f64 (.f64 (fma.f64 im im (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (.f64 (+.f64 re im) (-.f64 re im)))))

simplify522.0ms (5.6%)

Memory

-13.3MiB live, 782.3MiB allocated

Algorithm

1×	egg-herbie

Rules

12 394×	`lower-fma.f64`
12 394×	`lower-fma.f32`
6 962×	`lower-*.f64`
6 962×	`lower-*.f32`
6 410×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1151	10547
1	3528	9725
0	9360	9195

Stop Event

1×	iter limit
1×	node limit

Counts

456 → 439

Calls

Call 1

Inputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(/ (log re) (log 10))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(log im)
(log im)
(log im)
(log im)
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/8 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 10))
(+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))
(+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))))
(+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (+ (* 8/3 (/ (pow im 6) (* (pow re 6) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))))
(/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 10))
(+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))
(+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))))
(+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (+ (* 8/3 (/ (pow im 6) (* (pow re 6) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))))
(/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 10))
(+ (* -1 (/ (log im) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (* 1/2 (pow re 2))) (log 10))))
(+ (* -1 (/ (log im) (log 10))) (+ (* (pow im 2) (+ (* -2 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log (* 1/2 (pow re 2))) (log 10))))
(+ (* -1 (/ (log im) (log 10))) (+ (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 2 (/ 1 (* (pow re 4) (log 10)))))) (* 2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log (* 1/2 (pow re 2))) (log 10))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/24 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/24 (/ (pow re 6) (* (pow im 6) (log 10)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log (/ 1/2 im)) (* -2 (log (/ 1 re))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+ (log (/ 1/2 im)) (* -2 (log (/ -1 re))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+ (log (* 1/2 (pow re 2))) (* -1 (log im)))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2)))))))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2)))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(/ (log re) (log 10))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(sqrt re)
(+ (sqrt re) (* -1/2 (* im (sqrt (/ 1 re)))))
(+ (sqrt re) (* im (+ (* -1/2 (sqrt (/ 1 re))) (* 7/8 (* im (sqrt (/ 1 (pow re 3))))))))
(+ (sqrt re) (* im (+ (* -1/2 (sqrt (/ 1 re))) (* im (+ (* -9/16 (* im (sqrt (/ 1 (pow re 5))))) (* 7/8 (sqrt (/ 1 (pow re 3)))))))))
(sqrt im)
(* im (+ (sqrt (/ 1 im)) (* -1/2 (* (sqrt (/ 1 (pow im 3))) re))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* 1/2 (* (sqrt (/ 1 (pow im 5))) (- (pow re 2) (* -1 (pow re 2))))))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 7))) (+ (* 1/4 (* im (pow re 2))) (* re (- (pow re 2) (* -1 (pow re 2))))))) (* 1/2 (* (sqrt (/ 1 (pow im 5))) (- (pow re 2) (* -1 (pow re 2)))))))))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(* -1 (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))
(* -1 (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 5))) (- (* -1 (pow re 2)) (pow re 2)))) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))
(* -1 (* im (+ (* -1 (/ (+ (* 1/2 (* (sqrt im) (- (* -1 (pow re 2)) (pow re 2)))) (* 1/2 (* (sqrt (/ 1 im)) (+ (* -1 (* re (- (* -1 (pow re 2)) (pow re 2)))) (* -1/4 (/ (* im (pow re 2)) (pow (sqrt -1) 2))))))) (pow im 3))) (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))
(sqrt im)
(+ (sqrt im) (* -1/2 (* (sqrt (/ 1 im)) re)))
(+ (sqrt im) (* re (+ (* -1/2 (sqrt (/ 1 im))) (* 7/8 (* (sqrt (/ 1 (pow im 3))) re)))))
(+ (sqrt im) (* re (+ (* -1/2 (sqrt (/ 1 im))) (* re (+ (* -9/16 (* (sqrt (/ 1 (pow im 5))) re)) (* 7/8 (sqrt (/ 1 (pow im 3)))))))))
(sqrt re)
(* re (+ (sqrt (/ 1 re)) (* -1/2 (* im (sqrt (/ 1 (pow re 3)))))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 (pow re 5))) (- (pow im 2) (* -1 (pow im 2))))))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (+ (* -1/2 (* (sqrt (/ 1 (pow re 7))) (+ (* 1/4 (* (pow im 2) re)) (* im (- (pow im 2) (* -1 (pow im 2))))))) (* 1/2 (* (sqrt (/ 1 (pow re 5))) (- (pow im 2) (* -1 (pow im 2)))))))))
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
(* -1 (* re (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))
(* -1 (* re (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (+ (* -1/2 (* (sqrt (/ 1 (pow re 5))) (- (* -1 (pow im 2)) (pow im 2)))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2))))))
(* -1 (* re (+ (* -1 (/ (+ (* 1/2 (* (sqrt re) (- (* -1 (pow im 2)) (pow im 2)))) (* 1/2 (* (sqrt (/ 1 re)) (+ (* -1 (* im (- (* -1 (pow im 2)) (pow im 2)))) (* -1/4 (/ (* (pow im 2) re) (pow (sqrt -1) 2))))))) (pow re 3))) (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2))))))
(/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10))
(+ (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(+ (* (pow im 2) (+ (* -1/2 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow re 4) (log 10)))) (* 1/3 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))
(* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))
(* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))
(/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10))
(+ (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(+ (* (pow re 2) (+ (* -1/2 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow im 4) (log 10)))) (* 1/3 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))
(* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))
(* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10)))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))
(* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)))
(+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* -1/2 (* (/ (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2)))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow re 2)))))) (* 1/4 (* (/ 1 (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))))))
(+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* 1/4 (* (/ 1 (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow re 2)))) (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow im 2) (- (* 1/6 (/ 1 (* (pow re 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (* (pow re 2) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow re 2)))))))))))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow re 6) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2))))))) (* (log (/ 1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))))
(* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow re 6) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2))))))) (* (log (/ -1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))))
(* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)))
(+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* -1/2 (* (/ (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2)))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow im 2)))))) (* 1/4 (* (/ 1 (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))))))
(+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* 1/4 (* (/ 1 (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (pow re 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow im 2)))) (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow re 2) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (* (pow im 2) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow im 2)))))))))))
(* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow im 6) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2))))))) (* (log (/ 1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))))
(* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow im 6) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2))))))) (* (log (/ -1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* 1/2 (log (pow re 2)))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* 1/2 (log (pow im 2)))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
re
(+ re (* -1 im))
(+ re (* im (- (* 2 (/ im re)) 1)))
(+ re (* im (- (* im (+ (* -2 (/ im (pow re 2))) (* 2 (/ 1 re)))) 1)))
im
(* im (+ 1 (* -1 (/ re im))))
(* im (- (+ 1 (/ (pow re 2) (pow im 2))) (+ (* -1 (/ (pow re 2) (pow im 2))) (/ re im))))
(* im (- (+ 1 (+ (* -1 (/ (* re (- (pow re 2) (* -1 (pow re 2)))) (pow im 3))) (/ (pow re 2) (pow im 2)))) (+ (* -1 (/ (pow re 2) (pow im 2))) (/ re im))))
im
(* -1 (* im (- (/ re im) 1)))
(* -1 (* im (- (* -1 (/ (- (* -1 (/ (- (* -1 (pow re 2)) (pow re 2)) im)) re) im)) 1)))
(* -1 (* im (- (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* re (- (* -1 (pow re 2)) (pow re 2))) im)) (* -1 (pow re 2))) (pow re 2)) im)) re) im)) 1)))
im
(+ im (* -1 re))
(+ im (* re (- (* 2 (/ re im)) 1)))
(+ im (* re (- (* re (+ (* -2 (/ re (pow im 2))) (* 2 (/ 1 im)))) 1)))
re
(* re (+ 1 (* -1 (/ im re))))
(* re (- (+ 1 (/ (pow im 2) (pow re 2))) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re))))
(* re (- (+ 1 (+ (* -1 (/ (* im (- (pow im 2) (* -1 (pow im 2)))) (pow re 3))) (/ (pow im 2) (pow re 2)))) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re))))
re
(* -1 (* re (- (/ im re) 1)))
(* -1 (* re (- (* -1 (/ (- (* -1 (/ (- (* -1 (pow im 2)) (pow im 2)) re)) im) re)) 1)))
(* -1 (* re (- (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* im (- (* -1 (pow im 2)) (pow im 2))) re)) (* -1 (pow im 2))) (pow im 2)) re)) im) re)) 1)))
(sqrt im)
(+ (sqrt im) (* 1/2 (* (sqrt (/ 1 im)) re)))
(+ (sqrt im) (* re (+ (* -1/8 (* (sqrt (/ 1 (pow im 3))) re)) (* 1/2 (sqrt (/ 1 im))))))
(+ (sqrt im) (* re (+ (* 1/2 (sqrt (/ 1 im))) (* re (+ (* -1/8 (sqrt (/ 1 (pow im 3)))) (* 1/16 (* (sqrt (/ 1 (pow im 5))) re)))))))
(sqrt re)
(* re (+ (sqrt (/ 1 re)) (* 1/2 (* im (sqrt (/ 1 (pow re 3)))))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* im (sqrt (/ 1 (pow re 3))))))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (pow im 3) (sqrt (/ 1 (pow re 7))))) (* 1/2 (* im (sqrt (/ 1 (pow re 3)))))))))
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
(* -1 (* re (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))
(* -1 (* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2))))))
(* -1 (* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (/ (pow im 3) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))))
(sqrt re)
(+ (sqrt re) (* 1/2 (* im (sqrt (/ 1 re)))))
(+ (sqrt re) (* im (+ (* -1/8 (* im (sqrt (/ 1 (pow re 3))))) (* 1/2 (sqrt (/ 1 re))))))
(+ (sqrt re) (* im (+ (* 1/2 (sqrt (/ 1 re))) (* im (+ (* -1/8 (sqrt (/ 1 (pow re 3)))) (* 1/16 (* im (sqrt (/ 1 (pow re 5))))))))))
(sqrt im)
(* im (+ (sqrt (/ 1 im)) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re))))))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (/ (pow re 3) (pow (sqrt -1) 4)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))))
(log (pow re 2))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(* -2 (log (/ 1 im)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(* -2 (log (/ -1 im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(log (pow im 2))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(* -2 (log (/ 1 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(* -2 (log (/ -1 re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))

Outputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (.f64 re re) (fma.f64 #s(literal -1/8 binary64) (/.f64 (.f64 re re) (.f64 im (.f64 im im))) (/.f64 #s(literal 1/2 binary64) im)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal 1/16 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (.f64 re #s(literal 1/2 binary64)) (/.f64 (.f64 im im) (*.f64 re re)) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(.f64 re (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (fma.f64 (.f64 re #s(literal 1/2 binary64)) (/.f64 (.f64 im im) (*.f64 re re)) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(neg.f64 (fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) re))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (.f64 im im) (fma.f64 #s(literal -1/8 binary64) (/.f64 (.f64 im im) (.f64 re (.f64 re re))) (/.f64 #s(literal 1/2 binary64) re)) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 #s(literal 1/16 binary64) (/.f64 (.f64 im im) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (.f64 im #s(literal 1/2 binary64)) (/.f64 (.f64 re re) (*.f64 im im)) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) im)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) (/.f64 (.f64 re re) (*.f64 im im)) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(neg.f64 (fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(neg.f64 (fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) im))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re re) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/2 binary64) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (.f64 #s(literal 1/720 binary64) (pow.f64 im #s(literal 6 binary64))) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (.f64 #s(literal 1/720 binary64) (pow.f64 im #s(literal 6 binary64))) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(/ (log re) (log 10))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 im im) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/2 binary64) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (/.f64 (.f64 #s(literal 1/720 binary64) (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (log.f64 im))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (log.f64 re) (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 re))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im))) (/.f64 (.f64 #s(literal 1/720 binary64) (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (.f64 re re) (fma.f64 #s(literal -1/8 binary64) (/.f64 (.f64 re re) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/8 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 (/.f64 (.f64 re re) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/24 binary64) (/.f64 #s(literal -1/8 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/2 binary64) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 10))
(/.f64 (fma.f64 (neg.f64 (log.f64 re)) #s(literal -2 binary64) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
(+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))
(fma.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64))) #s(literal -2 binary64) (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (log (/ 1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (+ (* 8/3 (/ (pow im 6) (* (pow re 6) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 8/3 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 10))
(/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
(+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))
(fma.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))) #s(literal -2 binary64) (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (/ 1/2 im)) (log 10)))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (log (/ -1 re)) (log 10))) (+ (* -2 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (+ (* 8/3 (/ (pow im 6) (* (pow re 6) (log 10)))) (/ (log (/ 1/2 im)) (log 10))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 8/3 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 10))
(/.f64 (-.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log im) (log 10))) (+ (* 2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log (* 1/2 (pow re 2))) (log 10))))
(-.f64 (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log im) (log 10))) (+ (* (pow im 2) (+ (* -2 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log (* 1/2 (pow re 2))) (log 10))))
(-.f64 (fma.f64 (.f64 im im) (fma.f64 (/.f64 (.f64 im im) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -2 binary64) (/.f64 #s(literal 2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log im) (log 10))) (+ (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 2 (/ 1 (* (pow re 4) (log 10)))))) (* 2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log (* 1/2 (pow re 2))) (log 10))))
(-.f64 (fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 (/.f64 (.f64 im im) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal 8/3 binary64) (/.f64 #s(literal -2 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/24 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal 1/24 binary64) (pow.f64 re #s(literal 6 binary64))) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10)))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/8 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/24 (/ (pow re 6) (* (pow im 6) (log 10)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
(-.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/24 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 #s(literal -1/8 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/24 binary64) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (log.f64 im))
(+ (log (/ 1/2 im)) (* -2 (log (/ 1 re))))
(fma.f64 (neg.f64 (log.f64 re)) #s(literal -2 binary64) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (fma.f64 (neg.f64 (log.f64 re)) #s(literal -2 binary64) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (neg.f64 (log.f64 re)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (neg.f64 (log.f64 re)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 8/3 binary64) (/.f64 (.f64 #s(literal 2 binary64) (.f64 im im)) (*.f64 re re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (* -2 (log (/ -1 re))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+.f64 (fma.f64 #s(literal -2 binary64) (+.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (*.f64 #s(literal 8/3 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))
(+ (log (* 1/2 (pow re 2))) (* -1 (log im)))
(-.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 im))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (-.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 im)))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2)))))))
(fma.f64 (.f64 im im) (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -2 binary64) (/.f64 #s(literal 2 binary64) (.f64 re re))) (-.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 im)))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2)))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 8/3 binary64) (/.f64 #s(literal -2 binary64) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 2 binary64) (.f64 re re))) (-.f64 (log.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 im)))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (*.f64 #s(literal 1/24 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (*.f64 #s(literal 1/24 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(* 1/2 (/ (pow re 2) im))
(/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* 1/2 (/ (pow re 2) im))
(/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* 1/2 (/ (pow re 2) im))
(/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (.f64 #s(literal 1/2 binary64) (.f64 re re))) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (.f64 #s(literal 1/2 binary64) (.f64 re re))) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (.f64 #s(literal 1/2 binary64) (.f64 re re))) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (.f64 im #s(literal 1/2 binary64)) (/.f64 (.f64 re re) (*.f64 im im)) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (.f64 im #s(literal 1/2 binary64)) (/.f64 (.f64 re re) (*.f64 im im)) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (.f64 im #s(literal 1/2 binary64)) (/.f64 (.f64 re re) (*.f64 im im)) im)
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(.f64 (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64) #s(literal -1 binary64)) (neg.f64 im))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(.f64 (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64) #s(literal -1 binary64)) (neg.f64 im))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(.f64 (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64) #s(literal -1 binary64)) (neg.f64 im))
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 #s(literal 1/2 binary64) re) im)
(/ (log re) (log 10))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 im im) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/2 binary64) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (/.f64 (.f64 #s(literal 1/720 binary64) (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (*.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re re) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 #s(literal 1/2 binary64) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (.f64 #s(literal 1/720 binary64) (pow.f64 im #s(literal 6 binary64))) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (.f64 #s(literal 1/720 binary64) (pow.f64 im #s(literal 6 binary64))) #s(literal 120 binary64)) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 re))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im))) (/.f64 (.f64 #s(literal 1/720 binary64) (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (log.f64 im))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (log.f64 re) (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (.f64 im im) (fma.f64 #s(literal -1/8 binary64) (/.f64 (.f64 im im) (.f64 re (.f64 re re))) (/.f64 #s(literal 1/2 binary64) re)) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 #s(literal 1/16 binary64) (/.f64 (.f64 im im) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (.f64 im #s(literal 1/2 binary64)) (/.f64 (.f64 re re) (*.f64 im im)) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) im)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 (.f64 im #s(literal 1/2 binary64)) (/.f64 (.f64 re re) (*.f64 im im)) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(neg.f64 (fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(neg.f64 (fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (.f64 re re) (fma.f64 #s(literal -1/8 binary64) (/.f64 (.f64 re re) (.f64 im (.f64 im im))) (/.f64 #s(literal 1/2 binary64) im)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal 1/16 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (.f64 im (*.f64 im im)))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (.f64 re #s(literal 1/2 binary64)) (/.f64 (.f64 im im) (*.f64 re re)) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(.f64 re (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (fma.f64 (.f64 re #s(literal 1/2 binary64)) (/.f64 (.f64 im im) (*.f64 re re)) re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1 binary64))) (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(neg.f64 (fma.f64 re (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) re))
(sqrt re)
(sqrt.f64 re)
(+ (sqrt re) (* -1/2 (* im (sqrt (/ 1 re)))))
(fma.f64 (*.f64 #s(literal -1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 re))
(+ (sqrt re) (* im (+ (* -1/2 (sqrt (/ 1 re))) (* 7/8 (* im (sqrt (/ 1 (pow re 3))))))))
(fma.f64 im (fma.f64 #s(literal -1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (.f64 (.f64 #s(literal 7/8 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (.f64 re re)))))) (sqrt.f64 re))
(+ (sqrt re) (* im (+ (* -1/2 (sqrt (/ 1 re))) (* im (+ (* -9/16 (* im (sqrt (/ 1 (pow re 5))))) (* 7/8 (sqrt (/ 1 (pow re 3)))))))))
(fma.f64 im (fma.f64 im (fma.f64 #s(literal 7/8 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (.f64 re re)))) (.f64 (.f64 #s(literal -9/16 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))) (*.f64 #s(literal -1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (sqrt.f64 re))
(sqrt im)
(sqrt.f64 im)
(* im (+ (sqrt (/ 1 im)) (* -1/2 (* (sqrt (/ 1 (pow im 3))) re))))
(.f64 im (fma.f64 (.f64 #s(literal -1/2 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* 1/2 (* (sqrt (/ 1 (pow im 5))) (- (pow re 2) (* -1 (pow re 2))))))))
(.f64 im (fma.f64 (.f64 #s(literal -1/2 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im)))) (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 #s(literal 2 binary64) (*.f64 re re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 7))) (+ (* 1/4 (* im (pow re 2))) (* re (- (pow re 2) (* -1 (pow re 2))))))) (* 1/2 (* (sqrt (/ 1 (pow im 5))) (- (pow re 2) (* -1 (pow re 2)))))))))
(.f64 im (fma.f64 #s(literal -1/2 binary64) (fma.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im)))) (.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64)))) (fma.f64 re (.f64 #s(literal 2 binary64) (.f64 re re)) (.f64 #s(literal 1/4 binary64) (.f64 im (.f64 re re)))))) (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 #s(literal 2 binary64) (.f64 re re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(neg.f64 (neg.f64 (sqrt.f64 im)))
(* -1 (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))
(neg.f64 (.f64 im (fma.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (.f64 (.f64 #s(literal -1/2 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (*.f64 im im))))))))
(* -1 (* im (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (+ (* -1/2 (* (sqrt (/ 1 (pow im 5))) (- (* -1 (pow re 2)) (pow re 2)))) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))
(neg.f64 (.f64 im (fma.f64 #s(literal -1/2 binary64) (fma.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im)))) (.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (.f64 (.f64 re re) #s(literal -2 binary64)))) (*.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))))
(* -1 (* im (+ (* -1 (/ (+ (* 1/2 (* (sqrt im) (- (* -1 (pow re 2)) (pow re 2)))) (* 1/2 (* (sqrt (/ 1 im)) (+ (* -1 (* re (- (* -1 (pow re 2)) (pow re 2)))) (* -1/4 (/ (* im (pow re 2)) (pow (sqrt -1) 2))))))) (pow im 3))) (+ (* -1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))
(.f64 (fma.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (fma.f64 #s(literal -1/2 binary64) (.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im))))) (/.f64 (.f64 #s(literal -1/2 binary64) (fma.f64 (sqrt.f64 im) (.f64 (.f64 re re) #s(literal -2 binary64)) (.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (fma.f64 re (.f64 #s(literal 2 binary64) (.f64 re re)) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 im (.f64 re re))) #s(literal -1 binary64)))))) (.f64 im (*.f64 im im))))) (neg.f64 im))
(sqrt im)
(sqrt.f64 im)
(+ (sqrt im) (* -1/2 (* (sqrt (/ 1 im)) re)))
(fma.f64 (*.f64 #s(literal -1/2 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 im))
(+ (sqrt im) (* re (+ (* -1/2 (sqrt (/ 1 im))) (* 7/8 (* (sqrt (/ 1 (pow im 3))) re)))))
(fma.f64 re (fma.f64 (.f64 #s(literal 7/8 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im)))) (.f64 #s(literal -1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (sqrt.f64 im))
(+ (sqrt im) (* re (+ (* -1/2 (sqrt (/ 1 im))) (* re (+ (* -9/16 (* (sqrt (/ 1 (pow im 5))) re)) (* 7/8 (sqrt (/ 1 (pow im 3)))))))))
(fma.f64 re (fma.f64 re (fma.f64 #s(literal 7/8 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im)))) (.f64 (.f64 #s(literal -9/16 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))))) (*.f64 #s(literal -1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (sqrt.f64 im))
(sqrt re)
(sqrt.f64 re)
(* re (+ (sqrt (/ 1 re)) (* -1/2 (* im (sqrt (/ 1 (pow re 3)))))))
(.f64 re (fma.f64 (.f64 #s(literal -1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (.f64 re re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (* 1/2 (* (sqrt (/ 1 (pow re 5))) (- (pow im 2) (* -1 (pow im 2))))))))
(.f64 re (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 #s(literal 2 binary64) (.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (fma.f64 (.f64 #s(literal -1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (*.f64 re re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (+ (* -1/2 (* (sqrt (/ 1 (pow re 7))) (+ (* 1/4 (* (pow im 2) re)) (* im (- (pow im 2) (* -1 (pow im 2))))))) (* 1/2 (* (sqrt (/ 1 (pow re 5))) (- (pow im 2) (* -1 (pow im 2)))))))))
(.f64 re (fma.f64 #s(literal -1/2 binary64) (fma.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (.f64 re re)))) (.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (fma.f64 #s(literal 1/4 binary64) (.f64 re (.f64 im im)) (.f64 im (.f64 #s(literal 2 binary64) (.f64 im im)))))) (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 #s(literal 2 binary64) (.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
(neg.f64 (neg.f64 (sqrt.f64 re)))
(* -1 (* re (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))
(.f64 (fma.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (.f64 (.f64 #s(literal -1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (*.f64 re re)))))) (neg.f64 re))
(* -1 (* re (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (+ (* -1/2 (* (sqrt (/ 1 (pow re 5))) (- (* -1 (pow im 2)) (pow im 2)))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2))))))
(neg.f64 (.f64 re (fma.f64 #s(literal -1/2 binary64) (fma.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (.f64 re re)))) (.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (.f64 (.f64 im im) #s(literal -2 binary64)))) (*.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))))
(* -1 (* re (+ (* -1 (/ (+ (* 1/2 (* (sqrt re) (- (* -1 (pow im 2)) (pow im 2)))) (* 1/2 (* (sqrt (/ 1 re)) (+ (* -1 (* im (- (* -1 (pow im 2)) (pow im 2)))) (* -1/4 (/ (* (pow im 2) re) (pow (sqrt -1) 2))))))) (pow re 3))) (+ (* -1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2))))))
(neg.f64 (.f64 re (fma.f64 #s(literal -1/2 binary64) (.f64 im (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (.f64 re re))))) (fma.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (/.f64 (.f64 #s(literal -1/2 binary64) (fma.f64 (sqrt.f64 re) (.f64 (.f64 im im) #s(literal -2 binary64)) (.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 im (.f64 #s(literal 2 binary64) (.f64 im im)) (.f64 (.f64 #s(literal -1/4 binary64) (.f64 im im)) (/.f64 re #s(literal -1 binary64))))))) (.f64 re (*.f64 re re)))))))
(/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10))
(.f64 (log.f64 (.f64 re re)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(+ (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 (.f64 re re))))
(+ (* (pow im 2) (+ (* -1/2 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))
(fma.f64 (.f64 im im) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 im im)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 (.f64 re re)))))
(+ (* (pow im 2) (+ (* (pow im 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow re 4) (log 10)))) (* 1/3 (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow re 2) (log 10))))) (/ (* (log (pow re 2)) (pow (sqrt 1/2) 2)) (log 10)))
(fma.f64 (.f64 (.f64 im im) (.f64 im im)) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 im im) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 (.f64 re re)))))
(* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))
(fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (* (log (/ 1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))))))
(* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10)))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(+ (* -2 (/ (* (log (/ -1 im)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow re 4) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (+ (* 1/3 (/ (* (pow re 6) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))))
(-.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10))
(.f64 (log.f64 (.f64 im im)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(+ (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)) (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 2) (log 10))))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (.f64 re re) (.f64 im im)) (log.f64 (.f64 im im))))
(+ (* (pow re 2) (+ (* -1/2 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 4) (log 10)))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))
(fma.f64 (.f64 re re) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 re re)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (.f64 re re) (.f64 im im)) (log.f64 (.f64 im im)))))
(+ (* (pow re 2) (+ (* (pow re 2) (+ (* -1/2 (/ (pow (sqrt 1/2) 2) (* (pow im 4) (log 10)))) (* 1/3 (/ (* (pow re 2) (pow (sqrt 1/2) 2)) (* (pow im 6) (log 10)))))) (/ (pow (sqrt 1/2) 2) (* (pow im 2) (log 10))))) (/ (* (log (pow im 2)) (pow (sqrt 1/2) 2)) (log 10)))
(fma.f64 (.f64 re re) (.f64 (.f64 re re) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re re) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (.f64 re re) (.f64 im im)) (log.f64 (.f64 im im)))))
(* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -2 (/ (* (log (/ 1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))))
(* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10)))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10)))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -2 (/ (* (log (/ -1 re)) (pow (sqrt 1/2) 2)) (log 10))) (+ (* -1/2 (/ (* (pow im 4) (pow (sqrt 1/2) 2)) (* (pow re 4) (log 10)))) (+ (* 1/3 (/ (* (pow im 6) (pow (sqrt 1/2) 2)) (* (pow re 6) (log 10)))) (/ (* (pow im 2) (pow (sqrt 1/2) 2)) (* (pow re 2) (log 10))))))
(-.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2))
(.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)))
(fma.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 10 binary64)))) (.f64 (.f64 #s(literal 1/4 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (sqrt.f64 #s(literal 1/2 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (.f64 re re)))))))
(+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* -1/2 (* (/ (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2)))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow re 2)))))) (* 1/4 (* (/ 1 (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))))))
(fma.f64 (.f64 im im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (.f64 (.f64 im im) (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/16 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (.f64 re re))))))) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (.f64 re re))))) (sqrt.f64 #s(literal 1/2 binary64))) (.f64 #s(literal 1/4 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (.f64 re re))))) (.f64 (.f64 re re) (sqrt.f64 #s(literal 1/2 binary64)))))) (.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64))))))
(+ (* (sqrt (/ (log (pow re 2)) (log 10))) (sqrt 1/2)) (* (pow im 2) (+ (* 1/4 (* (/ 1 (* (pow re 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow re 2))))))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow re 2)))) (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow im 2) (- (* 1/6 (/ 1 (* (pow re 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (* (pow re 2) (* (log (pow re 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow re 2)))))))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 #s(literal 1/2 binary64) (.f64 (.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (.f64 re re)))) (.f64 im im)) (/.f64 (+.f64 (/.f64 #s(literal 1/6 binary64) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 #s(literal 1/4 binary64) (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/16 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (.f64 re re)))))) (.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (log.f64 (.f64 re re)))))) (sqrt.f64 #s(literal 1/2 binary64)))) (.f64 (.f64 #s(literal -1/2 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (.f64 re re))))) (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/16 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (.f64 re re)))))) (sqrt.f64 #s(literal 1/2 binary64))))) (.f64 #s(literal 1/4 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (.f64 re re))))) (.f64 (.f64 re re) (sqrt.f64 #s(literal 1/2 binary64)))))) (.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 10 binary64))))))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))
(fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 10 binary64)))) (.f64 (.f64 #s(literal 1/4 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (sqrt.f64 #s(literal -1 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))))
(fma.f64 (.f64 #s(literal 1/4 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (sqrt.f64 #s(literal -1 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))) (fma.f64 #s(literal 1/2 binary64) (.f64 (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal -1/16 binary64))) (.f64 (pow.f64 im #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 10 binary64)))))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow re 6) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2))))))) (* (log (/ 1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))))
(fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal -1/16 binary64))) (.f64 (pow.f64 im #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (.f64 #s(literal -1/4 binary64) (.f64 re re)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal -1/16 binary64))) (log.f64 im)))) (.f64 (pow.f64 im #s(literal 6 binary64)) (sqrt.f64 #s(literal -1 binary64)))))) (fma.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 10 binary64)))) (.f64 (.f64 #s(literal 1/4 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (sqrt.f64 #s(literal -1 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))))))
(* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))
(fma.f64 (.f64 #s(literal 1/4 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (sqrt.f64 #s(literal -1 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))))
(fma.f64 (.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))) #s(literal -1/16 binary64))) (.f64 (pow.f64 im #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (fma.f64 (.f64 #s(literal 1/4 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (sqrt.f64 #s(literal -1 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow re 6) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2))))))) (* (log (/ -1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))))
(fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))) #s(literal -1/16 binary64))) (.f64 (pow.f64 im #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal -1/4 binary64) (/.f64 (.f64 (.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))) #s(literal -1/16 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (.f64 (pow.f64 im #s(literal 6 binary64)) (sqrt.f64 #s(literal -1 binary64)))))) (fma.f64 (.f64 #s(literal 1/4 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (sqrt.f64 #s(literal -1 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))))
(* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2))
(.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)))
(fma.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 10 binary64)))) (.f64 (.f64 #s(literal 1/4 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (sqrt.f64 #s(literal 1/2 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (.f64 im im)))))))
(+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* -1/2 (* (/ (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2)))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow im 2)))))) (* 1/4 (* (/ 1 (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))))))
(fma.f64 (.f64 re re) (fma.f64 #s(literal -1/2 binary64) (.f64 (.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (.f64 im im)))) (.f64 re re)) (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/16 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (.f64 im im)))))) (sqrt.f64 #s(literal 1/2 binary64)))) (.f64 #s(literal 1/4 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (.f64 im im))))) (.f64 (.f64 im im) (sqrt.f64 #s(literal 1/2 binary64)))))) (.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(+ (* (sqrt (/ (log (pow im 2)) (log 10))) (sqrt 1/2)) (* (pow re 2) (+ (* 1/4 (* (/ 1 (* (pow im 2) (sqrt 1/2))) (sqrt (/ 1 (* (log 10) (log (pow im 2))))))) (* (pow re 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log (pow im 2)))) (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)))) (* 1/2 (* (/ (* (pow re 2) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (* (pow im 2) (* (log (pow im 2)) (pow (sqrt 1/2) 2))))))) (sqrt 1/2)) (sqrt (/ (log 10) (log (pow im 2)))))))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal 1/2 binary64) (.f64 (.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (.f64 im im)))) (.f64 re re)) (/.f64 (-.f64 (/.f64 #s(literal 1/6 binary64) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/16 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (.f64 im im))))))) (.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (log.f64 (.f64 im im))))) (sqrt.f64 #s(literal 1/2 binary64)))) (.f64 (.f64 #s(literal -1/2 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (.f64 im im))))) (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/16 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (log.f64 (.f64 im im)))))) (sqrt.f64 #s(literal 1/2 binary64))))) (.f64 #s(literal 1/4 binary64) (/.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (.f64 im im))))) (.f64 (.f64 im im) (sqrt.f64 #s(literal 1/2 binary64)))))) (.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 10 binary64))))))
(* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))
(fma.f64 (.f64 #s(literal 1/4 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (sqrt.f64 #s(literal -1 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64))))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))))
(fma.f64 #s(literal 1/2 binary64) (.f64 (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))) #s(literal -1/16 binary64))) (.f64 (pow.f64 re #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (fma.f64 (.f64 #s(literal 1/4 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (sqrt.f64 #s(literal -1 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64)))))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow im 6) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2))))))) (* (log (/ 1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))))
(fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))) #s(literal -1/16 binary64))) (.f64 (pow.f64 re #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (.f64 #s(literal -1/4 binary64) (.f64 im im)) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))) #s(literal -1/16 binary64))) (log.f64 re)))) (.f64 (pow.f64 re #s(literal 6 binary64)) (sqrt.f64 #s(literal -1 binary64)))))) (fma.f64 (.f64 #s(literal 1/4 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (sqrt.f64 #s(literal -1 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re))))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64)))))))
(* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))
(fma.f64 (.f64 #s(literal 1/4 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (sqrt.f64 #s(literal -1 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))))
(fma.f64 #s(literal 1/4 binary64) (.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (sqrt.f64 #s(literal -1 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))) (fma.f64 (.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))) #s(literal -1/16 binary64))) (.f64 (pow.f64 re #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (- (* 1/6 (/ (pow im 6) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2))))))) (* (log (/ -1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))))
(fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))) #s(literal -1/16 binary64))) (.f64 (pow.f64 re #s(literal 4 binary64)) (sqrt.f64 #s(literal -1 binary64)))) (.f64 #s(literal 1/2 binary64) (/.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal -1/4 binary64) (/.f64 (.f64 (.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))) #s(literal -1/16 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (.f64 (pow.f64 re #s(literal 6 binary64)) (sqrt.f64 #s(literal -1 binary64)))))) (fma.f64 (.f64 #s(literal 1/4 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (sqrt.f64 #s(literal -1 binary64))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(.f64 (log.f64 (.f64 re re)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 (.f64 re re))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (.f64 im im) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 im im)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 (.f64 re re)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (.f64 (.f64 im im) (.f64 im im)) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 im im) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 (.f64 re re)))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(.f64 (log.f64 (.f64 im im)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (.f64 re re) (.f64 im im)) (log.f64 (.f64 im im))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (.f64 re re) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 re re)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (.f64 re re) (.f64 im im)) (log.f64 (.f64 im im)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (.f64 re re) (.f64 (.f64 re re) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re re) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (+.f64 (/.f64 (.f64 re re) (.f64 im im)) (log.f64 (.f64 im im)))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (*.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* 1/2 (log (pow re 2)))
(.f64 #s(literal 1/2 binary64) (log.f64 (.f64 re re)))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 (.f64 re re))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (.f64 re re)) (.f64 (.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re)))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 re re))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* 1/2 (log (pow im 2)))
(.f64 #s(literal 1/2 binary64) (log.f64 (.f64 im im)))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(.f64 #s(literal 1/2 binary64) (+.f64 (/.f64 (.f64 re re) (.f64 im im)) (log.f64 (.f64 im im))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 im im))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 im im))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re))) (/.f64 (*.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
re
(+ re (* -1 im))
(-.f64 re im)
(+ re (* im (- (* 2 (/ im re)) 1)))
(fma.f64 im (fma.f64 #s(literal 2 binary64) (/.f64 im re) #s(literal -1 binary64)) re)
(+ re (* im (- (* im (+ (* -2 (/ im (pow re 2))) (* 2 (/ 1 re)))) 1)))
(fma.f64 im (fma.f64 im (fma.f64 #s(literal -2 binary64) (/.f64 im (*.f64 re re)) (/.f64 #s(literal 2 binary64) re)) #s(literal -1 binary64)) re)
im
(* im (+ 1 (* -1 (/ re im))))
(fma.f64 im (/.f64 re (neg.f64 im)) im)
(* im (- (+ 1 (/ (pow re 2) (pow im 2))) (+ (* -1 (/ (pow re 2) (pow im 2))) (/ re im))))
(.f64 im (+.f64 (/.f64 (.f64 re re) (.f64 im im)) (-.f64 #s(literal 1 binary64) (-.f64 (/.f64 re im) (/.f64 (.f64 re re) (*.f64 im im))))))
(* im (- (+ 1 (+ (* -1 (/ (* re (- (pow re 2) (* -1 (pow re 2)))) (pow im 3))) (/ (pow re 2) (pow im 2)))) (+ (* -1 (/ (pow re 2) (pow im 2))) (/ re im))))
(.f64 im (-.f64 (+.f64 #s(literal 1 binary64) (fma.f64 (neg.f64 re) (/.f64 (.f64 #s(literal 2 binary64) (.f64 re re)) (.f64 im (.f64 im im))) (/.f64 (.f64 re re) (.f64 im im)))) (-.f64 (/.f64 re im) (/.f64 (.f64 re re) (*.f64 im im)))))
im
(* -1 (* im (- (/ re im) 1)))
(neg.f64 (fma.f64 im (/.f64 re im) (neg.f64 im)))
(* -1 (* im (- (* -1 (/ (- (* -1 (/ (- (* -1 (pow re 2)) (pow re 2)) im)) re) im)) 1)))
(neg.f64 (fma.f64 im (/.f64 (-.f64 (/.f64 (.f64 #s(literal 2 binary64) (.f64 re re)) im) re) (neg.f64 im)) (neg.f64 im)))
(* -1 (* im (- (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* re (- (* -1 (pow re 2)) (pow re 2))) im)) (* -1 (pow re 2))) (pow re 2)) im)) re) im)) 1)))
(neg.f64 (fma.f64 im (/.f64 (-.f64 (/.f64 (fma.f64 re (/.f64 (.f64 #s(literal 2 binary64) (.f64 re re)) im) (.f64 (.f64 re re) #s(literal -2 binary64))) (neg.f64 im)) re) (neg.f64 im)) (neg.f64 im)))
im
(+ im (* -1 re))
(-.f64 im re)
(+ im (* re (- (* 2 (/ re im)) 1)))
(fma.f64 re (fma.f64 #s(literal 2 binary64) (/.f64 re im) #s(literal -1 binary64)) im)
(+ im (* re (- (* re (+ (* -2 (/ re (pow im 2))) (* 2 (/ 1 im)))) 1)))
(fma.f64 re (fma.f64 re (fma.f64 #s(literal -2 binary64) (/.f64 re (*.f64 im im)) (/.f64 #s(literal 2 binary64) im)) #s(literal -1 binary64)) im)
re
(* re (+ 1 (* -1 (/ im re))))
(fma.f64 re (/.f64 im (neg.f64 re)) re)
(* re (- (+ 1 (/ (pow im 2) (pow re 2))) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re))))
(.f64 re (+.f64 (/.f64 (.f64 im im) (.f64 re re)) (-.f64 #s(literal 1 binary64) (-.f64 (/.f64 im re) (/.f64 (.f64 im im) (*.f64 re re))))))
(* re (- (+ 1 (+ (* -1 (/ (* im (- (pow im 2) (* -1 (pow im 2)))) (pow re 3))) (/ (pow im 2) (pow re 2)))) (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re))))
(.f64 re (+.f64 (+.f64 (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (.f64 im (.f64 (.f64 im im) #s(literal -2 binary64))) (.f64 re (.f64 re re)))) (-.f64 #s(literal 1 binary64) (-.f64 (/.f64 im re) (/.f64 (.f64 im im) (.f64 re re))))))
re
(* -1 (* re (- (/ im re) 1)))
(*.f64 (+.f64 (/.f64 im re) #s(literal -1 binary64)) (neg.f64 re))
(* -1 (* re (- (* -1 (/ (- (* -1 (/ (- (* -1 (pow im 2)) (pow im 2)) re)) im) re)) 1)))
(neg.f64 (fma.f64 re (/.f64 (-.f64 (/.f64 (.f64 #s(literal 2 binary64) (.f64 im im)) re) im) (neg.f64 re)) (neg.f64 re)))
(* -1 (* re (- (* -1 (/ (- (* -1 (/ (- (+ (* -1 (/ (* im (- (* -1 (pow im 2)) (pow im 2))) re)) (* -1 (pow im 2))) (pow im 2)) re)) im) re)) 1)))
(neg.f64 (fma.f64 re (/.f64 (-.f64 (/.f64 (fma.f64 im (/.f64 (.f64 #s(literal 2 binary64) (.f64 im im)) re) (.f64 (.f64 im im) #s(literal -2 binary64))) (neg.f64 re)) im) (neg.f64 re)) (neg.f64 re)))
(sqrt im)
(sqrt.f64 im)
(+ (sqrt im) (* 1/2 (* (sqrt (/ 1 im)) re)))
(fma.f64 (*.f64 #s(literal 1/2 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (sqrt.f64 im))
(+ (sqrt im) (* re (+ (* -1/8 (* (sqrt (/ 1 (pow im 3))) re)) (* 1/2 (sqrt (/ 1 im))))))
(fma.f64 re (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (.f64 (.f64 re #s(literal -1/8 binary64)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im)))))) (sqrt.f64 im))
(+ (sqrt im) (* re (+ (* 1/2 (sqrt (/ 1 im))) (* re (+ (* -1/8 (sqrt (/ 1 (pow im 3)))) (* 1/16 (* (sqrt (/ 1 (pow im 5))) re)))))))
(fma.f64 re (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (.f64 re (fma.f64 #s(literal -1/8 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im)))) (.f64 (*.f64 #s(literal 1/16 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))))))) (sqrt.f64 im))
(sqrt re)
(sqrt.f64 re)
(* re (+ (sqrt (/ 1 re)) (* 1/2 (* im (sqrt (/ 1 (pow re 3)))))))
(.f64 re (fma.f64 (.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (.f64 re re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (* 1/2 (* im (sqrt (/ 1 (pow re 3))))))))
(.f64 re (fma.f64 (.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (.f64 re re)))) (fma.f64 (.f64 #s(literal -1/8 binary64) (.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))))
(* re (+ (sqrt (/ 1 re)) (+ (* -1/8 (* (pow im 2) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (pow im 3) (sqrt (/ 1 (pow re 7))))) (* 1/2 (* im (sqrt (/ 1 (pow re 3)))))))))
(.f64 re (+.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 (.f64 #s(literal 1/16 binary64) (.f64 im (.f64 im im))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (fma.f64 (.f64 #s(literal -1/8 binary64) (.f64 im im)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (.f64 (.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (.f64 re re)))))))))
(* -1 (* (sqrt re) (pow (sqrt -1) 2)))
(neg.f64 (neg.f64 (sqrt.f64 re)))
(* -1 (* re (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))
(.f64 (fma.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (.f64 (.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (*.f64 re re)))))) (neg.f64 re))
(* -1 (* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2))))))
(.f64 (fma.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (.f64 re re)))) (.f64 (.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 im im) #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64))))))) (neg.f64 re))
(* -1 (* re (+ (* -1/8 (* (/ (pow im 2) (pow (sqrt -1) 2)) (sqrt (/ 1 (pow re 5))))) (+ (* 1/16 (* (/ (pow im 3) (pow (sqrt -1) 4)) (sqrt (/ 1 (pow re 7))))) (+ (* 1/2 (* im (sqrt (/ 1 (pow re 3))))) (* (sqrt (/ 1 re)) (pow (sqrt -1) 2)))))))
(neg.f64 (.f64 re (fma.f64 #s(literal -1/8 binary64) (.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))) (/.f64 (.f64 im im) #s(literal -1 binary64))) (fma.f64 #s(literal 1/16 binary64) (.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 7 binary64)))) (/.f64 (.f64 im (.f64 im im)) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 4 binary64)))) (fma.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (.f64 (.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (.f64 re re))))))))))
(sqrt re)
(sqrt.f64 re)
(+ (sqrt re) (* 1/2 (* im (sqrt (/ 1 re)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (sqrt.f64 re))
(+ (sqrt re) (* im (+ (* -1/8 (* im (sqrt (/ 1 (pow re 3))))) (* 1/2 (sqrt (/ 1 re))))))
(fma.f64 im (fma.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)) (.f64 (.f64 #s(literal -1/8 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (.f64 re re)))))) (sqrt.f64 re))
(+ (sqrt re) (* im (+ (* 1/2 (sqrt (/ 1 re))) (* im (+ (* -1/8 (sqrt (/ 1 (pow re 3)))) (* 1/16 (* im (sqrt (/ 1 (pow re 5))))))))))
(fma.f64 im (fma.f64 im (fma.f64 #s(literal -1/8 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 re (.f64 re re)))) (.f64 (.f64 #s(literal 1/16 binary64) im) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 5 binary64)))))) (*.f64 #s(literal 1/2 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) re)))) (sqrt.f64 re))
(sqrt im)
(sqrt.f64 im)
(* im (+ (sqrt (/ 1 im)) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re))))
(.f64 im (fma.f64 (.f64 #s(literal 1/2 binary64) re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)))))
(.f64 im (fma.f64 #s(literal 1/2 binary64) (.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im))))) (fma.f64 (.f64 #s(literal -1/8 binary64) (.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))))
(* im (+ (sqrt (/ 1 im)) (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (pow re 2))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (pow re 3))) (* 1/2 (* (sqrt (/ 1 (pow im 3))) re))))))
(.f64 im (+.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (fma.f64 #s(literal 1/2 binary64) (.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im))))) (fma.f64 (.f64 #s(literal 1/16 binary64) (.f64 re (.f64 re re))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64)))) (.f64 (.f64 #s(literal -1/8 binary64) (.f64 re re)) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64)))))))))
(* -1 (* (sqrt im) (pow (sqrt -1) 2)))
(neg.f64 (neg.f64 (sqrt.f64 im)))
(* -1 (* im (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))
(.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im))))) (*.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)))) (neg.f64 im))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2))))))
(.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im))))) (fma.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im)) (.f64 (.f64 #s(literal -1/8 binary64) (/.f64 (*.f64 re re) #s(literal -1 binary64))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))))) (neg.f64 im))
(* -1 (* im (+ (* -1/8 (* (sqrt (/ 1 (pow im 5))) (/ (pow re 2) (pow (sqrt -1) 2)))) (+ (* 1/16 (* (sqrt (/ 1 (pow im 7))) (/ (pow re 3) (pow (sqrt -1) 4)))) (+ (* 1/2 (* (sqrt (/ 1 (pow im 3))) re)) (* (sqrt (/ 1 im)) (pow (sqrt -1) 2)))))))
(neg.f64 (.f64 im (fma.f64 #s(literal -1/8 binary64) (/.f64 (.f64 (.f64 re re) (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 5 binary64))))) #s(literal -1 binary64)) (fma.f64 #s(literal 1/16 binary64) (.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 7 binary64)))) (/.f64 (.f64 re (.f64 re re)) (pow.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal 4 binary64)))) (fma.f64 #s(literal 1/2 binary64) (.f64 re (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 im (.f64 im im))))) (.f64 #s(literal -1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) im))))))))
(log (pow re 2))
(log.f64 (*.f64 re re))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(fma.f64 (.f64 im im) (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 re re))) (log.f64 (.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 re re))) (log.f64 (*.f64 re re)))
(* -2 (log (/ 1 im)))
(*.f64 #s(literal 2 binary64) (log.f64 im))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (/.f64 (.f64 re re) (.f64 im im)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 im im))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (.f64 re re) (.f64 im im)))))
(* -2 (log (/ -1 im)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (/.f64 (.f64 re re) (.f64 im im)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (/.f64 (.f64 re re) (.f64 im im))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (.f64 re re) (.f64 im im)))))
(log (pow im 2))
(log.f64 (*.f64 im im))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+.f64 (/.f64 (.f64 re re) (.f64 im im)) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(fma.f64 (.f64 re re) (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 im im))) (log.f64 (.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 im im))) (log.f64 (*.f64 im im)))
(* -2 (log (/ 1 re)))
(neg.f64 (*.f64 (log.f64 re) #s(literal -2 binary64)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 (neg.f64 (log.f64 re)) #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 re re)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (neg.f64 (log.f64 re)) #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 re re))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 (neg.f64 (log.f64 re)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (.f64 im im) (.f64 re re)))))
(* -2 (log (/ -1 re)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 re re)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 re re))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 (.f64 im im) (.f64 re re)))))

eval215.0ms (2.3%)

Memory: 29.1MiB live, 486.4MiB allocated
Compiler: Compiled 42 455 to 4 425 computations (89.6% saved)

prune201.0ms (2.1%)

Memory

14.5MiB live, 459.5MiB allocated

Pruning

22 alts after pruning (19 fresh and 3 done)

	Pruned	Kept	Total
New	1 505	14	1 519
Fresh	5	5	10
Picked	2	3	5
Done	0	0	0
Total	1 512	22	1 534

Accuracy

100.0%

Counts

1 534 → 22

Alt Table

Click to see full alt table

Status	Accuracy	Program
	74.5%	(pow.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
	35.6%	(pow.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) #s(literal 2 binary64))
▶	54.2%	(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
	54.2%	(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))))
	54.2%	(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
	98.3%	(/.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) (log.f64 #s(literal 1/10 binary64)))
▶	97.8%	(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
✓	98.3%	(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
	54.2%	(/.f64 (log.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 10 binary64)))
▶	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
	97.1%	(/.f64 (log.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (+.f64 re im)))) (log.f64 #s(literal 10 binary64)))
✓	97.9%	(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
▶	97.9%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
	97.8%	(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
	16.8%	(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))) (log.f64 #s(literal 10 binary64))))
	74.5%	(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
	35.7%	(.f64 (pow.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
	97.4%	(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
	54.1%	(.f64 (.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
	97.8%	(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
▶	73.9%	(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))

Compiler

Compiled 660 to 455 computations (31.1% saved)

simplify73.0ms (0.8%)

Memory

-8.7MiB live, 68.2MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score	Program
✓	cost-diff	0	(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
✓	cost-diff	0	(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
✓	cost-diff	192	(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64))
✓	cost-diff	12928	(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
✓	cost-diff	0	(/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
✓	cost-diff	0	(log.f64 #s(literal 1/10 binary64))
✓	cost-diff	0	(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
✓	cost-diff	1088	(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
✓	cost-diff	0	(log.f64 im)
✓	cost-diff	0	(log.f64 #s(literal 10 binary64))
✓	cost-diff	0	(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
✓	cost-diff	704	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
✓	cost-diff	0	(log.f64 #s(literal 1/10 binary64))
✓	cost-diff	0	(log.f64 im)
✓	cost-diff	0	(neg.f64 (log.f64 im))
✓	cost-diff	0	(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
✓	cost-diff	0	(neg.f64 (log.f64 #s(literal 1/10 binary64)))
✓	cost-diff	0	(log.f64 (hypot.f64 re im))
✓	cost-diff	0	(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	cost-diff	5120	(hypot.f64 re im)

Rules

428×	`lower-*.f32`
424×	`lower-*.f64`
420×	`lower-fma.f32`
418×	`lower-fma.f64`
300×	`lower-/.f32`

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	27	142
0	49	140
1	70	139
2	101	133
3	138	133
4	197	133
5	259	133
6	378	133
7	594	133
8	776	133
9	879	133
10	951	133
11	1002	133
12	1025	133
13	1046	133
14	1147	133
15	1249	133
16	1381	133
17	1461	133
18	1474	133
19	1483	133
20	1494	133
21	1504	133
22	1504	133
0	1504	133

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(log.f64 (hypot.f64 re im))
(hypot.f64 re im)
re
im
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 im))
(log.f64 im)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 im)
im
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
#s(literal -1 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
#s(literal 2 binary64)
(log.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 im im (*.f64 re re))
im
(*.f64 re re)
re
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 im)
im
#s(literal -1 binary64)

Outputs
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(log.f64 (hypot.f64 re im))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(hypot.f64 re im)
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
re
im
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (log.f64 im))
(log.f64 im)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 im)
im
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
#s(literal -1 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
#s(literal 2 binary64)
(log.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 im im (*.f64 re re))
im
(*.f64 re re)
re
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 im)
im
#s(literal -1 binary64)

localize119.0ms (1.3%)

Memory

18.5MiB live, 290.0MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score	Program
✓	accuracy	100.0%	(log.f64 #s(literal 10 binary64))
✓	accuracy	100.0%	(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
✓	accuracy	99.3%	(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
✓	accuracy	98.6%	(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
✓	accuracy	99.6%	(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
✓	accuracy	98.8%	(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
✓	accuracy	98.8%	(log.f64 #s(literal 1/10 binary64))
✓	accuracy	60.3%	(log.f64 (fma.f64 im im (*.f64 re re)))
✓	accuracy	100.0%	(log.f64 im)
✓	accuracy	100.0%	(log.f64 #s(literal 10 binary64))
✓	accuracy	99.7%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
✓	accuracy	99.3%	(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
✓	accuracy	100.0%	(neg.f64 (log.f64 im))
✓	accuracy	100.0%	(log.f64 im)
✓	accuracy	99.3%	(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
✓	accuracy	98.8%	(log.f64 #s(literal 1/10 binary64))
✓	accuracy	100.0%	(neg.f64 (log.f64 #s(literal 1/10 binary64)))
✓	accuracy	100.0%	(log.f64 (hypot.f64 re im))
✓	accuracy	99.3%	(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	accuracy	98.8%	(log.f64 #s(literal 1/10 binary64))

Samples

58.0ms	194×	0	valid
21.0ms	62×	0	invalid

Compiler

Compiled 163 to 30 computations (81.6% saved)

Precisions

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

ival-log: 16.0ms (31% of total)

ival-div: 14.0ms (27.1% of total)

ival-hypot: 5.0ms (9.7% of total)

const: 5.0ms (9.7% of total)

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

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

ival-neg: 2.0ms (3.9% of total)

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

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

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

exact: 0.0ms (0% of total)

series122.0ms (1.3%)

Memory

-27.1MiB live, 181.9MiB allocated

Counts

18 → 240

Calls

Call 1

Inputs
#<alt (hypot.f64 re im)>
#<alt (/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))>
#<alt (log.f64 (hypot.f64 re im))>
#<alt (neg.f64 (log.f64 #s(literal 1/10 binary64)))>
#<alt (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))>
#<alt (neg.f64 (log.f64 im))>
#<alt (log.f64 im)>
#<alt (log.f64 #s(literal 1/10 binary64))>
#<alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))>
#<alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))>
#<alt (log.f64 #s(literal 10 binary64))>
#<alt (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))>
#<alt (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))>
#<alt (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))>
#<alt (exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))>
#<alt (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64))>
#<alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))>
#<alt (log.f64 (fma.f64 im im (*.f64 re re)))>

Outputs
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))>
#<alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))>
#<alt re>
#<alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 re)>
#<alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))>
#<alt re>
#<alt (+ re (* 1/2 (/ (pow im 2) re)))>
#<alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))>
#<alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 im)>
#<alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))>
#<alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (/ (log (/ 1 re)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))>
#<alt (/ (log (/ -1 re)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))>
#<alt (* -1 (/ (log re) (log 1/10)))>
#<alt (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))>
#<alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))>
#<alt (/ (log (/ -1 im)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))>
#<alt (log im)>
#<alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (* -1 (log (/ 1 re)))>
#<alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (* -1 (log (/ -1 re)))>
#<alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))>
#<alt (log re)>
#<alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))>
#<alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (log (/ -1 im)))>
#<alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (log im))>
#<alt (* -1 (log im))>
#<alt (* -1 (log im))>
#<alt (* -1 (log im))>
#<alt (log (/ 1 im))>
#<alt (log (/ 1 im))>
#<alt (log (/ 1 im))>
#<alt (log (/ 1 im))>
#<alt (* -1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (* -1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (* -1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (* -1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (log 10) (log im))>
#<alt (/ (log 10) (log im))>
#<alt (/ (log 10) (log im))>
#<alt (/ (log 10) (log im))>
#<alt (* -1 (/ (log 10) (log (/ 1 im))))>
#<alt (* -1 (/ (log 10) (log (/ 1 im))))>
#<alt (* -1 (/ (log 10) (log (/ 1 im))))>
#<alt (* -1 (/ (log 10) (log (/ 1 im))))>
#<alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (* -1/2 (/ (log (pow re 2)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))>
#<alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))>
#<alt (/ (log (/ -1 im)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))>
#<alt (* -1/2 (/ (log (pow im 2)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))>
#<alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (/ (log (/ 1 re)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))>
#<alt (/ (log (/ -1 re)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))>
#<alt (/ 2 (log (pow re 2)))>
#<alt (+ (* -2 (/ (pow im 2) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ 1 (log (pow re 2)))))>
#<alt (+ (* (pow im 2) (- (* (pow im 2) (+ (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2))) (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))>
#<alt (+ (* (pow im 2) (- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 2/3 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 2)))) (+ (* 2 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 3)))) (* 2 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 4)))))))) (+ (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))) (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))>
#<alt (/ -1 (log (/ 1 im)))>
#<alt (- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))>
#<alt (- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))>
#<alt (- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (+ (* 1/6 (/ (pow re 6) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))))>
#<alt (/ -1 (log (/ -1 im)))>
#<alt (- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))>
#<alt (- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))>
#<alt (- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (+ (* 1/6 (/ (pow re 6) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))))>
#<alt (/ 2 (log (pow im 2)))>
#<alt (+ (* -2 (/ (pow re 2) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ 1 (log (pow im 2)))))>
#<alt (+ (* (pow re 2) (- (* (pow re 2) (+ (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2))) (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))>
#<alt (+ (* (pow re 2) (- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 2/3 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 2)))) (+ (* 2 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 3)))) (* 2 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 4)))))))) (+ (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))) (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))>
#<alt (/ -1 (log (/ 1 re)))>
#<alt (- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))>
#<alt (- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))>
#<alt (- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (+ (* 1/6 (/ (pow im 6) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))))>
#<alt (/ -1 (log (/ -1 re)))>
#<alt (- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))>
#<alt (- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))>
#<alt (- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (+ (* 1/6 (/ (pow im 6) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (* -1 (log (/ (log 10) (log im))))>
#<alt (* -1 (log (/ (log 10) (log im))))>
#<alt (* -1 (log (/ (log 10) (log im))))>
#<alt (* -1 (log (/ (log 10) (log im))))>
#<alt (* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))>
#<alt (* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))>
#<alt (* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))>
#<alt (* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))>
#<alt (* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))>
#<alt (* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))>
#<alt (* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))>
#<alt (* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))>
#<alt (log (/ (log 10) (log im)))>
#<alt (log (/ (log 10) (log im)))>
#<alt (log (/ (log 10) (log im)))>
#<alt (log (/ (log 10) (log im)))>
#<alt (log (* -1 (/ (log 10) (log (/ 1 im)))))>
#<alt (log (* -1 (/ (log 10) (log (/ 1 im)))))>
#<alt (log (* -1 (/ (log 10) (log (/ 1 im)))))>
#<alt (log (* -1 (/ (log 10) (log (/ 1 im)))))>
#<alt (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))>
#<alt (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))>
#<alt (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))>
#<alt (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))>
#<alt (log (pow re 2))>
#<alt (+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))>
#<alt (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))>
#<alt (+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))>
#<alt (* -2 (log (/ 1 im)))>
#<alt (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))>
#<alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))>
#<alt (* -2 (log (/ -1 im)))>
#<alt (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))>
#<alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))>
#<alt (log (pow im 2))>
#<alt (+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))>
#<alt (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))>
#<alt (+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))>
#<alt (* -2 (log (/ 1 re)))>
#<alt (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))>
#<alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))>
#<alt (* -2 (log (/ -1 re)))>
#<alt (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))>
#<alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))>
#<alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))>

Calls

60 calls:

Time	Variable		Point	Expression
39.0ms	im	@	0	(/ (neg (log im)) (log 1/10))
19.0ms	im	@	-inf	(* (log (/ (log 10) (log im))) -1)
17.0ms	im	@	inf	(* (log (/ (log 10) (log im))) -1)
15.0ms	im	@	0	(* (log (/ (log 10) (log im))) -1)
11.0ms	re	@	-inf	(/ 2 (log (+ (* im im) (* re re))))

rewrite461.0ms (4.9%)

Memory

19.0MiB live, 409.2MiB allocated

Algorithm

1×	batch-egg-rewrite

Rules

3 440×	`lower-*.f32`
3 436×	`lower-*.f64`
3 252×	`lower-fma.f32`
3 250×	`lower-fma.f64`
2 348×	`lower-/.f32`

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	27	102
0	49	89
1	148	82
2	783	81
3	5941	81
0	8391	81

Stop Event

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

Counts

18 → 1 004

Calls

Call 1

Inputs
(hypot.f64 re im)
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(log.f64 (hypot.f64 re im))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 im))
(log.f64 im)
(log.f64 #s(literal 1/10 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(log.f64 #s(literal 10 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log.f64 (fma.f64 im im (*.f64 re re)))

Outputs
(exp.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)))
(exp.f64 (.f64 (.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (fma.f64 re re (.f64 im im)))) #s(literal 1/4 binary64)))
(exp.f64 (.f64 (log.f64 (exp.f64 #s(literal 1 binary64))) (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))))
(exp.f64 (.f64 (log.f64 (exp.f64 (log.f64 (fma.f64 re re (.f64 im im))))) #s(literal 1/2 binary64)))
(exp.f64 (.f64 (log.f64 (exp.f64 #s(literal 1/2 binary64))) (log.f64 (fma.f64 re re (.f64 im im)))))
(exp.f64 (.f64 (log.f64 (exp.f64 #s(literal -1/2 binary64))) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im))))))
(hypot.f64 re im)
(hypot.f64 im re)
(hypot.f64 im (exp.f64 (log.f64 re)))
(hypot.f64 (exp.f64 (log.f64 re)) im)
(sqrt.f64 (fma.f64 re re (*.f64 im im)))
(sqrt.f64 (exp.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re))) (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))))))
(/.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))))
(/.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (sqrt.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (neg.f64 (.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))))) (sqrt.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(/.f64 (neg.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (neg.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))))) (neg.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))))) (neg.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/2 binary64))
(pow.f64 (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (.f64 (fma.f64 re re (.f64 im im)) (fma.f64 re re (*.f64 im im))) #s(literal 1/4 binary64))
(pow.f64 (exp.f64 #s(literal 1 binary64)) (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)))
(pow.f64 (exp.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))
(pow.f64 (exp.f64 #s(literal -1/2 binary64)) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(pow.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re))) (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))))) #s(literal -1 binary64))
(.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re)))))
(.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))
(.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im)))))
(.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))
(.f64 (pow.f64 (fma.f64 re re (.f64 im im)) #s(literal 1/4 binary64)) (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal 1/4 binary64)))
(+.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64))))
(exp.f64 (.f64 (log.f64 (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(neg.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (.f64 im im)))))
(/.f64 #s(literal -1 binary64) (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (.f64 im im)))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64))) #s(literal 1 binary64))
(/.f64 #s(literal 1/2 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))
(/.f64 (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -2 binary64))
(/.f64 (.f64 #s(literal 1 binary64) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im))))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))
(/.f64 (.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal -1 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)))
(/.f64 (.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal 1 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 2 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal -2 binary64))
(/.f64 (.f64 #s(literal -1/2 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))
(/.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(pow.f64 (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal -1 binary64))
(.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64))))
(.f64 #s(literal -1 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))
(.f64 (log.f64 (fma.f64 re re (.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64))) #s(literal 1 binary64))
(.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal 1/2 binary64) (pow.f64 (neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (.f64 im im))))) #s(literal -1 binary64)))
(.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (.f64 im im))))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(.f64 #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 10 binary64))))
(.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(.f64 (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))))
(.f64 (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(.f64 (.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #s(literal 1/2 binary64))
(.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)))
(.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (log.f64 (fma.f64 re re (.f64 im im))))
(.f64 (/.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(.f64 (/.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
(log.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im))))))
(+.f64 (.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))) #s(literal 1/2 binary64))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1/2 binary64))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 im re))))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 im re))))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/2 binary64))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (*.f64 (+.f64 re im) (-.f64 re im))))))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (*.f64 (+.f64 re im) (-.f64 re im))))))
(exp.f64 (.f64 (neg.f64 (log.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))) #s(literal -1 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(-.f64 #s(literal 0 binary64) (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re))) (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))))))
(-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))))) (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))))) (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) #s(literal 2 binary64)) (/.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) #s(literal 2 binary64)))
(-.f64 (/.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (/.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 im re))) #s(literal 2 binary64)))
(-.f64 (/.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 2 binary64)) (/.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 re im))) #s(literal 2 binary64)))
(-.f64 (log.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (log.f64 (sqrt.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(-.f64 (log.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (neg.f64 (.f64 (+.f64 re im) (-.f64 im re)))))) (log.f64 (sqrt.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (log.f64 (sqrt.f64 (neg.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (sqrt.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (log.f64 (neg.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))))) (log.f64 (neg.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (neg.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 im re))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (.f64 im im))) (.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(neg.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64)))
(neg.f64 (log.f64 (sqrt.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(neg.f64 (log.f64 (/.f64 (sqrt.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (sqrt.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))))
(neg.f64 (log.f64 (/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 im re))) (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))))))
(neg.f64 (log.f64 (/.f64 (sqrt.f64 (.f64 (+.f64 re im) (-.f64 re im))) (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))))))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 2 binary64))
(/.f64 #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64)) #s(literal -1 binary64))
(/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -2 binary64))
(/.f64 #s(literal -1/2 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (.f64 #s(literal 1 binary64) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im))))) #s(literal -2 binary64))
(/.f64 (.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal 1 binary64)) #s(literal -2 binary64))
(pow.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)) #s(literal 1 binary64))
(.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)) (log.f64 (exp.f64 #s(literal 1 binary64))))
(.f64 #s(literal 1 binary64) (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))
(.f64 #s(literal -1 binary64) (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(.f64 #s(literal 2 binary64) (.f64 #s(literal 1/4 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64))
(.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 (exp.f64 #s(literal 1/2 binary64))))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
(.f64 #s(literal 1/2 binary64) (log.f64 (exp.f64 (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal -1/2 binary64))
(.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 (exp.f64 #s(literal -1/2 binary64))))
(.f64 #s(literal -1/2 binary64) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))))
(.f64 #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 #s(literal -1/2 binary64) (.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64)))
(.f64 #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal 1 binary64)))
(.f64 #s(literal 1/4 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (fma.f64 re re (.f64 im im)))))
(.f64 (pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)))
(log.f64 #s(literal 10 binary64))
(+.f64 (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(exp.f64 (log.f64 (log.f64 #s(literal 10 binary64))))
(exp.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(exp.f64 (*.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 #s(literal -1 binary64))) (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))) #s(literal 0 binary64))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 0 binary64))))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (exp.f64 (log.f64 #s(literal -1 binary64))) (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64)))
(exp.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) #s(literal -1/2 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(fma.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(/.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 im))))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 1/10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (log.f64 im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) #s(literal 1 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) #s(literal -1 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal 1 binary64)) (.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1 binary64)) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/.f64 (.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
(/.f64 (.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
(/.f64 (.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(/.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (log.f64 im))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))) (log.f64 im))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 im)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (/.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (log.f64 im)))))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 im) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 (log.f64 im) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(log.f64 (/.f64 #s(literal 1 binary64) im))
(+.f64 (neg.f64 (log.f64 im)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (neg.f64 (log.f64 im)))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal 1 binary64) (neg.f64 im))))
(+.f64 (log.f64 (pow.f64 im #s(literal -1/2 binary64))) (log.f64 (pow.f64 im #s(literal -1/2 binary64))))
(exp.f64 (*.f64 (neg.f64 (log.f64 (neg.f64 (log.f64 im)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 im))
(-.f64 #s(literal 0 binary64) (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (log.f64 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (neg.f64 (neg.f64 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 im)))
(-.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
(fma.f64 (log.f64 im) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 im)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im)) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 im) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 0 binary64))
(neg.f64 (log.f64 im))
(neg.f64 (log.f64 (neg.f64 (neg.f64 im))))
(/.f64 (log.f64 im) #s(literal -1 binary64))
(/.f64 (neg.f64 (log.f64 im)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (log.f64 im))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) #s(literal 1 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal 1 binary64)) (log.f64 im))
(/.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(/.f64 (*.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (log.f64 im))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (neg.f64 (log.f64 im)))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 0 binary64))))
(pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 im) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (log.f64 im) #s(literal -1 binary64))
(*.f64 (neg.f64 (log.f64 im)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im)))
(*.f64 #s(literal -1 binary64) (log.f64 im))
(*.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
(*.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(log.f64 im)
(+.f64 (log.f64 im) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 im))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 im)))
(+.f64 (log.f64 (pow.f64 im #s(literal 1/2 binary64))) (log.f64 (pow.f64 im #s(literal 1/2 binary64))))
(exp.f64 (log.f64 (log.f64 im)))
(exp.f64 (*.f64 (neg.f64 (log.f64 (log.f64 im))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 1 binary64)))
(-.f64 (log.f64 im) #s(literal 0 binary64))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) im) #s(literal 1 binary64))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (/.f64 #s(literal 1 binary64) im))))
(-.f64 (log.f64 (neg.f64 im)) (log.f64 #s(literal -1 binary64)))
(fma.f64 (log.f64 im) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (log.f64 im) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)) #s(literal 0 binary64))
(fma.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 0 binary64))
(neg.f64 (neg.f64 (log.f64 im)))
(neg.f64 (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) im) #s(literal 1 binary64))))
(/.f64 (log.f64 im) #s(literal 1 binary64))
(/.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (neg.f64 (log.f64 im)))
(/.f64 (*.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(/.f64 (*.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (log.f64 im))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (log.f64 im))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(pow.f64 (log.f64 im) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (log.f64 im) #s(literal 1 binary64))
(*.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 im))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1/2 binary64)))
(log.f64 #s(literal 1/10 binary64))
(+.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(exp.f64 (*.f64 (neg.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(neg.f64 (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))
(+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64)))
(exp.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) #s(literal -1/2 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(fma.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(/.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 im))))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 1/10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (log.f64 im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) #s(literal 1 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) #s(literal -1 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal 1 binary64)) (.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1 binary64)) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/.f64 (.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
(/.f64 (.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
(/.f64 (.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(/.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (log.f64 im))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))) (log.f64 im))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 im)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (/.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (log.f64 im)))))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 im) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 (log.f64 im) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(+.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(+.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 0 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(exp.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(fma.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(/.f64 (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))) (exp.f64 (log.f64 (neg.f64 (log.f64 im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (.f64 (log.f64 im) (neg.f64 (log.f64 im))))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (log.f64 im)) (.f64 (log.f64 im) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (neg.f64 (log.f64 im))) (.f64 (log.f64 im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64)) (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal -1 binary64)) (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (neg.f64 (log.f64 im))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64)) (.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im))))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im))) (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64)))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (.f64 (neg.f64 (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal 1 binary64)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal 1 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 (log.f64 #s(literal 10 binary64)) (exp.f64 (neg.f64 (log.f64 (log.f64 im)))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64))))
(*.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64)))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (log.f64 im))
(log.f64 #s(literal 10 binary64))
(+.f64 (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(exp.f64 (log.f64 (log.f64 #s(literal 10 binary64))))
(exp.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(exp.f64 (*.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 0 binary64))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 0 binary64))
(fma.f64 (exp.f64 (log.f64 #s(literal -1 binary64))) (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))) #s(literal 0 binary64))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 0 binary64))))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(pow.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (exp.f64 (log.f64 #s(literal -1 binary64))) (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(+.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64))))
(exp.f64 (.f64 (log.f64 (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(neg.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (.f64 im im)))))
(/.f64 #s(literal -1 binary64) (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (.f64 im im)))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64))) #s(literal 1 binary64))
(/.f64 #s(literal 1/2 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im))))))
(/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))
(/.f64 (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -2 binary64))
(/.f64 (.f64 #s(literal 1 binary64) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im))))) (*.f64 (log.f64 #s(literal 10 binary64)) #s(literal -2 binary64)))
(/.f64 (.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal -1 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)))
(/.f64 (.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal 1 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal 2 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal -2 binary64))
(/.f64 (.f64 #s(literal -1/2 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))
(/.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(pow.f64 (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal -1 binary64))
(.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64))))
(.f64 #s(literal -1 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))
(.f64 (log.f64 (fma.f64 re re (.f64 im im))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64))) #s(literal 1 binary64))
(.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal 1/2 binary64) (pow.f64 (neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re re (.f64 im im))))) #s(literal -1 binary64)))
(.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (.f64 im im))))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(.f64 #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 10 binary64))))
(.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(.f64 (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))))
(.f64 (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(.f64 (.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #s(literal 1/2 binary64))
(.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (neg.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal -1/2 binary64)))
(.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1 binary64)))
(.f64 (pow.f64 (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64)))
(.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (log.f64 (fma.f64 re re (.f64 im im))))
(.f64 (/.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(.f64 (/.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))))
(exp.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64))) #s(literal -1 binary64)))
(exp.f64 (.f64 (neg.f64 (log.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)))) #s(literal 1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(neg.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)))
(/.f64 #s(literal -1 binary64) (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64)))
(/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
(/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 #s(literal -2 binary64) (.f64 #s(literal 1 binary64) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im))))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64))
(pow.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1 binary64))
(.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))
(.f64 #s(literal -1 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))
(.f64 #s(literal 2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))
(.f64 #s(literal 2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal 1 binary64)))
(.f64 (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal 1 binary64))
(.f64 #s(literal -2 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))
(.f64 #s(literal -2 binary64) (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal 1 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal 2 binary64))
(.f64 (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal -2 binary64))
(.f64 (pow.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) #s(literal -1/2 binary64)) (pow.f64 (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1/2 binary64)) #s(literal -1/2 binary64)))
(+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 0 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (*.f64 (log.f64 (exp.f64 #s(literal -1 binary64))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64)))
(exp.f64 (.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) #s(literal 2 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) #s(literal -1/2 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(fma.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(/.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
(/.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 im))))
(/.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 1/10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (log.f64 im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (-.f64 #s(literal 0 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) #s(literal 1 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) #s(literal -1 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal 1 binary64)) (.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1 binary64)) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/.f64 (.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
(/.f64 (.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))))
(/.f64 (.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(/.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (log.f64 im))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))) (log.f64 im))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 im)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (/.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64)))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (log.f64 im)))))
(*.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(*.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))) (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 im) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(*.f64 (/.f64 (log.f64 im) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 0 binary64))
(+.f64 (log.f64 (log.f64 im)) (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(+.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(+.f64 (log.f64 (neg.f64 (log.f64 im))) (neg.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(+.f64 (log.f64 (neg.f64 (log.f64 im))) (log.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))))
(+.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))) (log.f64 (log.f64 im)))
(+.f64 (neg.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))) (log.f64 (neg.f64 (log.f64 im))))
(+.f64 (neg.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(+.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (log.f64 #s(literal -1 binary64)))
(+.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
(+.f64 (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (log.f64 (/.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64))))
(+.f64 (.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)) (.f64 (neg.f64 (log.f64 (log.f64 im))) #s(literal -1 binary64)))
(+.f64 (log.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(+.f64 (log.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64))))) (log.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (log.f64 im))))))
(+.f64 (log.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64)))) (log.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (/.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 2 binary64)))))
(+.f64 (log.f64 (/.f64 (log.f64 im) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))) (*.f64 #s(literal 2 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(+.f64 (log.f64 (/.f64 (log.f64 im) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))) (log.f64 (log.f64 #s(literal 1/10 binary64))))
(-.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 0 binary64))
(-.f64 (log.f64 (log.f64 im)) (log.f64 (log.f64 #s(literal 10 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(-.f64 (log.f64 (neg.f64 (log.f64 im))) (log.f64 (log.f64 #s(literal 1/10 binary64))))
(-.f64 (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))) (neg.f64 (log.f64 (log.f64 im))))
(-.f64 (neg.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))) (neg.f64 (log.f64 (neg.f64 (log.f64 im)))))
(-.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (log.f64 #s(literal -1 binary64)))
(-.f64 (log.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (log.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64)))))
(-.f64 (log.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (log.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(-.f64 (log.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 10 binary64))))) (log.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 im)))))
(-.f64 (log.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (log.f64 #s(literal 1/10 binary64))))) (log.f64 (pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (log.f64 im))))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))) (.f64 #s(literal 2 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im))))) (log.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64)))))
(-.f64 (log.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))))
(-.f64 (log.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) #s(literal 1 binary64))) (log.f64 (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (log.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) #s(literal -1 binary64))) (log.f64 (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64)))))
(-.f64 (log.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal 1 binary64))) (log.f64 (.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (log.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1 binary64))) (log.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(-.f64 (log.f64 (.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))))) (log.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64)))))
(-.f64 (log.f64 (.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))))) (log.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(-.f64 (log.f64 (.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))))) (log.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64)))))
(-.f64 (log.f64 (.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))))) (log.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64)))) (log.f64 (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))) (log.f64 (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))))
(-.f64 (log.f64 (.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))))) (.f64 #s(literal 2 binary64) (log.f64 (log.f64 im))))
(-.f64 (log.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))))) (log.f64 (log.f64 im)))
(-.f64 (log.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))) (.f64 #s(literal 2 binary64) (log.f64 (log.f64 im))))
(-.f64 (log.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64))))) (log.f64 (log.f64 im)))
(fma.f64 #s(literal 1 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (log.f64 (log.f64 im)) (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (log.f64 im)))
(fma.f64 #s(literal -1 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (neg.f64 (log.f64 im))))
(fma.f64 #s(literal -1 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (log.f64 im))) (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal 2 binary64) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) #s(literal 0 binary64))
(fma.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64) #s(literal 0 binary64))
(fma.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (log.f64 (exp.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(fma.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64) (*.f64 (neg.f64 (log.f64 (log.f64 im))) #s(literal -1 binary64)))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (log.f64 (/.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64))))
(fma.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
(fma.f64 #s(literal -1/2 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (log.f64 (/.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 1 binary64))))
(fma.f64 #s(literal -1/2 binary64) (log.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) #s(literal 0 binary64))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(neg.f64 (*.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64)))
(/.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64))) (neg.f64 (fma.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))) (neg.f64 (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64)))) (fma.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64)))) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 (.f64 #s(literal -1 binary64) (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64)))) (fma.f64 (log.f64 (log.f64 im)) (log.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))))
(/.f64 (.f64 #s(literal -1 binary64) (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64)))) (log.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 (.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal -1 binary64)) (fma.f64 (log.f64 (log.f64 im)) (log.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))))
(/.f64 (.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))) #s(literal -1 binary64)) (log.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(*.f64 #s(literal 1 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(*.f64 #s(literal -1 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(.f64 #s(literal 2 binary64) (.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (log.f64 (exp.f64 #s(literal -1 binary64))))
(.f64 #s(literal -1/2 binary64) (log.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(+.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 0 binary64))
(+.f64 (log.f64 (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 (log.f64 im))))
(+.f64 (log.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (exp.f64 (neg.f64 (log.f64 (log.f64 im))))))
(+.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(+.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 (neg.f64 (log.f64 im)))))
(+.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal 1 binary64))))
(+.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal 1 binary64))))
(+.f64 (neg.f64 (log.f64 (log.f64 im))) (log.f64 (log.f64 #s(literal 10 binary64))))
(+.f64 (log.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal -1 binary64)))
(+.f64 (neg.f64 (log.f64 (neg.f64 (log.f64 im)))) (log.f64 (log.f64 #s(literal 1/10 binary64))))
(+.f64 (log.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))) (log.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))))
(+.f64 (log.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64))) (log.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64))))
(+.f64 (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64))) (log.f64 (log.f64 #s(literal 1/10 binary64))))
(+.f64 (log.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))))) (*.f64 #s(literal 2 binary64) (log.f64 (log.f64 im))))
(+.f64 (log.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))))) (log.f64 (log.f64 im)))
(-.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 0 binary64))
(-.f64 (log.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (log.f64 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (neg.f64 (log.f64 im))))
(-.f64 (neg.f64 (log.f64 (log.f64 im))) (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(-.f64 (log.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal -1 binary64)))
(-.f64 (log.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (log.f64 (*.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(-.f64 (log.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))) (log.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (/.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (fma.f64 (log.f64 (log.f64 im)) (log.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)))) (/.f64 (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64)) (fma.f64 (log.f64 (log.f64 im)) (log.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)))))
(-.f64 (/.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (log.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) (/.f64 (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64)) (log.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(-.f64 (neg.f64 (log.f64 (neg.f64 (log.f64 im)))) (neg.f64 (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (log.f64 (exp.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))))) (log.f64 (exp.f64 (log.f64 (neg.f64 (log.f64 im))))))
(-.f64 (log.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))) (*.f64 #s(literal 1/2 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
(-.f64 (log.f64 (.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal 1 binary64))) (log.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))))
(-.f64 (log.f64 (.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) #s(literal -1 binary64))) (log.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (neg.f64 (log.f64 im)))))
(-.f64 (log.f64 (.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1 binary64))) (log.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(-.f64 (log.f64 (.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal -1 binary64))) (log.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))))
(-.f64 (log.f64 (.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))) (log.f64 (.f64 (log.f64 im) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(-.f64 (log.f64 (.f64 #s(literal 1 binary64) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))) (log.f64 (.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (log.f64 (.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))) (log.f64 (.f64 (neg.f64 (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
(-.f64 (log.f64 (.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))) (log.f64 (.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))) (.f64 #s(literal 2 binary64) (log.f64 (log.f64 im))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (log.f64 (.f64 (log.f64 im) (neg.f64 (log.f64 im)))))
(-.f64 (log.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (log.f64 im))) (log.f64 (.f64 (log.f64 im) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))))
(-.f64 (log.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (neg.f64 (log.f64 im)))) (log.f64 (.f64 (log.f64 im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
(-.f64 (log.f64 (.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))) (.f64 #s(literal 2 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (log.f64 (.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))) (log.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64))))
(-.f64 (log.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))) (log.f64 (log.f64 #s(literal 1/10 binary64))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal 3 binary64)))) (log.f64 (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (*.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))))))
(-.f64 (log.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))) (log.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
(-.f64 (log.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))) (.f64 #s(literal 2 binary64) (log.f64 (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))) (log.f64 (log.f64 #s(literal 1/10 binary64))))
(fma.f64 #s(literal 1 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal 0 binary64))
(fma.f64 #s(literal 1 binary64) (log.f64 (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 (log.f64 im))))
(fma.f64 #s(literal 1 binary64) (log.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (exp.f64 (neg.f64 (log.f64 (log.f64 im))))))
(fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 0 binary64))
(fma.f64 #s(literal -1 binary64) (log.f64 (log.f64 im)) (log.f64 (log.f64 #s(literal 10 binary64))))
(fma.f64 #s(literal -1 binary64) (log.f64 (neg.f64 (log.f64 im))) (log.f64 (log.f64 #s(literal 1/10 binary64))))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))) (neg.f64 (log.f64 (log.f64 im))))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (log.f64 #s(literal 10 binary64)))) (log.f64 (exp.f64 (neg.f64 (log.f64 (log.f64 im))))))
(fma.f64 #s(literal -1 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (log.f64 #s(literal -1 binary64)))
(fma.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (log.f64 (exp.f64 #s(literal -1 binary64))) #s(literal 0 binary64))
(fma.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)))) #s(literal 0 binary64))
(fma.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) #s(literal 0 binary64))
(neg.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))) (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64))) (fma.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))))
(/.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64)))) (neg.f64 (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(/.f64 (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (neg.f64 (log.f64 (log.f64 im))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (-.f64 (.f64 (neg.f64 (log.f64 (log.f64 im))) (neg.f64 (log.f64 (log.f64 im)))) (.f64 (log.f64 (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 (log.f64 im)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (*.f64 #s(literal 0 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (neg.f64 (log.f64 im))) #s(literal 3 binary64))) (fma.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (log.f64 #s(literal 1/10 binary64))) (fma.f64 (log.f64 (neg.f64 (log.f64 im))) (log.f64 (neg.f64 (log.f64 im))) (*.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (neg.f64 (log.f64 im)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (*.f64 (neg.f64 (log.f64 (log.f64 im))) (neg.f64 (log.f64 (log.f64 im))))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(/.f64 (-.f64 (.f64 (log.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (log.f64 #s(literal 1/10 binary64)))) (.f64 (log.f64 (neg.f64 (log.f64 im))) (log.f64 (neg.f64 (log.f64 im))))) (log.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))))
(pow.f64 (/.f64 (fma.f64 (log.f64 (log.f64 im)) (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))) (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(*.f64 #s(literal -1 binary64) (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(*.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (log.f64 (exp.f64 #s(literal -1 binary64))))
(.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 (log.f64 im)) (log.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)))))
(.f64 (-.f64 (pow.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(log.f64 (fma.f64 re re (*.f64 im im)))
(+.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 im re))))))
(+.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))))
(+.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(+.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(+.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
(+.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (neg.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(+.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(+.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (/.f64 (fma.f64 re re (.f64 im im)) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(+.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(+.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (neg.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(+.f64 (log.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(+.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (neg.f64 (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (.f64 (+.f64 re im) (-.f64 im re))))))
(+.f64 (log.f64 (neg.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (/.f64 #s(literal 1 binary64) (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))))))
(+.f64 (neg.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))
(+.f64 (neg.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))))
(+.f64 (neg.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))))
(+.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (fma.f64 re re (*.f64 im im))))
(+.f64 (log.f64 (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im))) (log.f64 (+.f64 re im)))
(+.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (fma.f64 re re (*.f64 im im))))
(+.f64 (log.f64 (/.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (fma.f64 (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (log.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im))) (-.f64 (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 im im) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))))
(+.f64 (log.f64 (/.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 (+.f64 re im) (-.f64 re im))))))) (log.f64 (-.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (.f64 re re) (*.f64 (+.f64 re im) (-.f64 re im))))))
(+.f64 (log.f64 (/.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (fma.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (.f64 im im) (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))))))) (log.f64 (fma.f64 re (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (-.f64 (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 re (.f64 re (.f64 re re))))))))
(+.f64 (log.f64 (/.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (-.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 (-.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(+.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (fma.f64 im (.f64 im im) (.f64 re (.f64 re re))) (-.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))))) (log.f64 (fma.f64 (.f64 re re) (fma.f64 re re (.f64 im im)) (.f64 im (.f64 im (.f64 im im))))))
(+.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))) (log.f64 (fma.f64 (.f64 re re) (fma.f64 re re (.f64 im im)) (.f64 im (.f64 im (.f64 im im))))))
(exp.f64 (.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(-.f64 #s(literal 0 binary64) (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))))
(-.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (.f64 (+.f64 re im) (-.f64 im re))))
(-.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))))))
(-.f64 (log.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))))))) (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (*.f64 im im))))))))
(-.f64 (log.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))))))) (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (fma.f64 im (.f64 im im) (.f64 re (.f64 re re))) (-.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 re (.f64 re re)) (.f64 re (*.f64 re re))))))))
(-.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 im (.f64 im im) (.f64 re (.f64 re re))) (-.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))))) (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (fma.f64 im (.f64 im im) (.f64 re (.f64 re re))) (-.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))))))
(-.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 im (.f64 im im) (.f64 re (.f64 re re))) (-.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (fma.f64 im (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (*.f64 im im)))))))))
(-.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))) (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))))
(-.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (fma.f64 re (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (*.f64 im im)))))))))
(-.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))))))
(-.f64 (log.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (neg.f64 (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (neg.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (/.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) #s(literal 1 binary64)) (/.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) #s(literal 1 binary64)))
(-.f64 (/.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 1 binary64)) (/.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1 binary64)))
(-.f64 (/.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64)) (/.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1 binary64)))
(-.f64 (log.f64 (-.f64 (.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (.f64 re (.f64 re (.f64 re re)))))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (-.f64 (.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 im (.f64 im (.f64 im im)))))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)))))) #s(literal 1 binary64))) (log.f64 (.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (log.f64 (.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)))))) #s(literal 1 binary64))) (log.f64 (.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (fma.f64 im (.f64 im im) (.f64 re (.f64 re re))) (-.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 im (.f64 im im) (.f64 re (.f64 re re))) (-.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re))))) #s(literal 1 binary64))) (log.f64 (.f64 (.f64 (fma.f64 im (.f64 im im) (.f64 re (.f64 re re))) (-.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 im (.f64 im im) (.f64 re (.f64 re re))) (-.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re))))) #s(literal 1 binary64))) (log.f64 (.f64 (fma.f64 im (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))))) (.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) #s(literal 1 binary64))) (log.f64 (.f64 (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) #s(literal 1 binary64))) (log.f64 (.f64 (fma.f64 re (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))))) (.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 1 binary64))) (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 1 binary64))) (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(-.f64 (log.f64 (neg.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))) (log.f64 (neg.f64 (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))))
(-.f64 (log.f64 (neg.f64 (.f64 (fma.f64 re re (.f64 im im)) (neg.f64 (.f64 (+.f64 re im) (-.f64 im re)))))) (log.f64 (neg.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (log.f64 (neg.f64 (neg.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (neg.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 (log.f64 (-.f64 (pow.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64)))) (log.f64 (fma.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 im re))) (fma.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))))))))
(-.f64 (log.f64 (-.f64 (pow.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) #s(literal 3 binary64)) (pow.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) #s(literal 3 binary64)))) (log.f64 (fma.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (fma.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))))
(-.f64 (log.f64 (-.f64 (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 im re)))))) (log.f64 (fma.f64 im (/.f64 (.f64 im (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (*.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (log.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 re (.f64 re (.f64 re re))) (.f64 (+.f64 re im) (-.f64 re im)))) (.f64 (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (.f64 (+.f64 re im) (-.f64 re im)))))) (log.f64 (fma.f64 re (/.f64 (.f64 re (.f64 re re)) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 im (.f64 im (.f64 im im))) (*.f64 (+.f64 re im) (-.f64 re im))))))
(-.f64 (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) #s(literal 1 binary64))) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))) #s(literal 1 binary64))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) #s(literal 1 binary64))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (log.f64 (.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 (fma.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (*.f64 im im)))))))
(-.f64 (log.f64 (.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re)))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 (fma.f64 (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))) (.f64 (fma.f64 im (.f64 im im) (.f64 re (.f64 re re))) (-.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re)))) (.f64 (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re re))) (.f64 (.f64 re (.f64 re re)) (.f64 re (*.f64 re re)))))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 im (.f64 im im) (.f64 re (.f64 re re))) (-.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 (.f64 (fma.f64 im (.f64 im im) (.f64 re (.f64 re re))) (-.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re))))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 im (.f64 im im) (.f64 re (.f64 re re))) (-.f64 (.f64 im (.f64 im im)) (.f64 re (.f64 re re))))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (fma.f64 im (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (.f64 re (.f64 re (.f64 re re))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (*.f64 im im))))))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im))))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (.f64 (fma.f64 re (.f64 re re) (.f64 im (.f64 im im))) (-.f64 (.f64 re (.f64 re re)) (.f64 im (.f64 im im))))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (fma.f64 re (.f64 (.f64 re (.f64 re re)) (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im (.f64 im im))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (*.f64 im im))))))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im)))) (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 im (.f64 im (.f64 im im))))))
(-.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (log.f64 (-.f64 im re)))
(-.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im))) (log.f64 (-.f64 re im)))
(fma.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 im re))))))
(fma.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 im re))))))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))))
(fma.f64 #s(literal -1 binary64) (log.f64 (.f64 (+.f64 re im) (-.f64 im re))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 #s(literal -1 binary64) (log.f64 (.f64 (+.f64 re im) (-.f64 re im))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))))
(fma.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1 binary64) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 im re))))))
(fma.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1 binary64) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))))
(fma.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1 binary64) (log.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1 binary64) (log.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (*.f64 (+.f64 re im) (-.f64 re im)))))
(neg.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(neg.f64 (log.f64 (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64))
(/.f64 (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) #s(literal 3 binary64))) (fma.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (fma.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 im re))) #s(literal 3 binary64))) (fma.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (fma.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 im re))) (log.f64 (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 re im))) #s(literal 3 binary64))) (fma.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (fma.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 re im))) (log.f64 (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im)))))))
(/.f64 (-.f64 (.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (.f64 (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))))
(/.f64 (-.f64 (.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))))) (.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 im re))) (log.f64 (.f64 (+.f64 re im) (-.f64 im re))))) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (-.f64 (.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))))) (.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 re im))) (log.f64 (.f64 (+.f64 re im) (-.f64 re im))))) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 re im)))))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64))
(.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
(.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))))
(.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1 binary64))

simplify479.0ms (5.1%)

Memory

13.9MiB live, 461.7MiB allocated

Algorithm

1×	egg-herbie

Rules

7 842×	`lower-fma.f64`
7 842×	`lower-fma.f32`
5 734×	`lower-*.f64`
5 734×	`lower-*.f32`
4 076×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	599	4398
1	1657	4312
2	5395	4286
0	8311	4091

Stop Event

1×	iter limit
1×	node limit

Counts

240 → 236

Calls

Call 1

Inputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(* -1 (/ (log im) (log 1/10)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(* -1 (/ (log re) (log 1/10)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (log im))
(* -1 (log im))
(* -1 (log im))
(* -1 (log im))
(log (/ 1 im))
(log (/ 1 im))
(log (/ 1 im))
(log (/ 1 im))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(log im)
(log im)
(log im)
(log im)
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (log 10) (log im))
(/ (log 10) (log im))
(/ (log 10) (log im))
(/ (log 10) (log im))
(* -1 (/ (log 10) (log (/ 1 im))))
(* -1 (/ (log 10) (log (/ 1 im))))
(* -1 (/ (log 10) (log (/ 1 im))))
(* -1 (/ (log 10) (log (/ 1 im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(* -1/2 (/ (log (pow re 2)) (log 1/10)))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(* -1/2 (/ (log (pow im 2)) (log 1/10)))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(/ 2 (log (pow re 2)))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ 1 (log (pow re 2)))))
(+ (* (pow im 2) (- (* (pow im 2) (+ (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2))) (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))
(+ (* (pow im 2) (- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 2/3 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 2)))) (+ (* 2 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 3)))) (* 2 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 4)))))))) (+ (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))) (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))
(/ -1 (log (/ 1 im)))
(- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))
(- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (+ (* 1/6 (/ (pow re 6) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))))
(/ -1 (log (/ -1 im)))
(- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))
(- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (+ (* 1/6 (/ (pow re 6) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))))
(/ 2 (log (pow im 2)))
(+ (* -2 (/ (pow re 2) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ 1 (log (pow im 2)))))
(+ (* (pow re 2) (- (* (pow re 2) (+ (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2))) (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))
(+ (* (pow re 2) (- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 2/3 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 2)))) (+ (* 2 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 3)))) (* 2 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 4)))))))) (+ (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))) (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))
(/ -1 (log (/ 1 re)))
(- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))
(- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (+ (* 1/6 (/ (pow im 6) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))))
(/ -1 (log (/ -1 re)))
(- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))
(- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (+ (* 1/6 (/ (pow im 6) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(* -1 (log (/ (log 10) (log im))))
(* -1 (log (/ (log 10) (log im))))
(* -1 (log (/ (log 10) (log im))))
(* -1 (log (/ (log 10) (log im))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(log (/ (log 10) (log im)))
(log (/ (log 10) (log im)))
(log (/ (log 10) (log im)))
(log (/ (log 10) (log im)))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log (pow re 2))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(* -2 (log (/ 1 im)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(* -2 (log (/ -1 im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(log (pow im 2))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(* -2 (log (/ 1 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(* -2 (log (/ -1 re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))

Outputs
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (.f64 re re) (fma.f64 #s(literal -1/8 binary64) (/.f64 (.f64 re re) (.f64 im (.f64 im im))) (/.f64 #s(literal 1/2 binary64) im)) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (.f64 re re) (fma.f64 re (.f64 re (fma.f64 #s(literal 1/16 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (.f64 im (*.f64 im im))))) (/.f64 #s(literal 1/2 binary64) im)) im)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(.f64 re (fma.f64 im (.f64 im (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) #s(literal 1 binary64)))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 re (fma.f64 im (.f64 im (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (/.f64 (.f64 #s(literal -1/8 binary64) (.f64 (.f64 im im) (.f64 im im))) (.f64 (.f64 re re) (*.f64 re re)))) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 re (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(neg.f64 (.f64 re (fma.f64 im (.f64 im (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) #s(literal 1 binary64))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(.f64 (fma.f64 #s(literal -1/8 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) (fma.f64 im (.f64 im (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) #s(literal 1 binary64))) (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(neg.f64 (fma.f64 re (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (fma.f64 #s(literal -1/8 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) re))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 im im) re) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 im (.f64 im (fma.f64 #s(literal -1/8 binary64) (/.f64 (.f64 im im) (.f64 re (.f64 re re))) (/.f64 #s(literal 1/2 binary64) re))) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 #s(literal 1/16 binary64) (/.f64 (.f64 im im) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (.f64 re (*.f64 re re)))) (/.f64 #s(literal 1/2 binary64) re)) re)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (.f64 re re) (.f64 im im)) (*.f64 #s(literal 1/2 binary64) im) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (.f64 #s(literal -1/8 binary64) (.f64 (.f64 re re) (.f64 re re))) (.f64 (.f64 im im) (*.f64 im im)))) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 im (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (.f64 #s(literal -1/8 binary64) (.f64 (.f64 re re) (.f64 re re))) (.f64 (.f64 im im) (*.f64 im im))))) im)
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(.f64 (fma.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) #s(literal 1 binary64)) (neg.f64 im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(neg.f64 (fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (.f64 #s(literal -1/8 binary64) (.f64 (.f64 re re) (.f64 re re))) (.f64 (.f64 im im) (*.f64 im im)))) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(neg.f64 (fma.f64 im (fma.f64 #s(literal 1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (/.f64 (.f64 #s(literal -1/8 binary64) (.f64 (.f64 re re) (.f64 re re))) (.f64 (.f64 im im) (*.f64 im im))))) im))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(-.f64 (/.f64 (.f64 (.f64 re re) #s(literal -1/2 binary64)) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(-.f64 (.f64 (.f64 re re) (fma.f64 re (.f64 re (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 1/10 binary64))))) (/.f64 #s(literal -1/2 binary64) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal -1/6 binary64) (/.f64 (.f64 re re) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 1/10 binary64))))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(-.f64 (/.f64 (.f64 (.f64 im im) #s(literal -1/2 binary64)) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(-.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64))))) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/4 binary64)) (.f64 (.f64 (.f64 re re) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(-.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (.f64 #s(literal -1/720 binary64) (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re (*.f64 re (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64))))) (fma.f64 #s(literal -1/720 binary64) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
(* -1 (/ (log re) (log 1/10)))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(-.f64 (/.f64 (.f64 (.f64 im im) #s(literal -1/2 binary64)) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal -1/2 binary64) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64)))))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 #s(literal -1/6 binary64) (/.f64 (.f64 im im) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 1/10 binary64))))) (/.f64 #s(literal -1/2 binary64) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64)))))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(-.f64 (/.f64 (.f64 (.f64 re re) #s(literal -1/2 binary64)) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (-.f64 (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal 1/4 binary64)) (.f64 (.f64 (.f64 im im) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(-.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (.f64 #s(literal -1/720 binary64) (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (*.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal -1/720 binary64) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (.f64 im im))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (.f64 im im) (.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 im (.f64 im (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (fma.f64 im (.f64 im (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 re)))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (fma.f64 im (.f64 im (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 re))) (/.f64 (.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) #s(literal 1/720 binary64)) (pow.f64 re #s(literal 6 binary64))))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 im (.f64 im (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal -1/4 binary64)) (.f64 (.f64 re re) (*.f64 re re)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) #s(literal 1/720 binary64)) (pow.f64 re #s(literal 6 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 im (.f64 im (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (.f64 im im) (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (.f64 im im) (fma.f64 im (.f64 im (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (.f64 re re) (.f64 re re))))) (/.f64 #s(literal 1/2 binary64) (*.f64 re re))) (log.f64 re))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (fma.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 (.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) #s(literal 1/720 binary64)) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (log.f64 im)))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(-.f64 (fma.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal -1/4 binary64)) (.f64 (.f64 im im) (*.f64 im im)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (/.f64 (.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) #s(literal 1/720 binary64)) (pow.f64 im #s(literal 6 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (log im))
(neg.f64 (log.f64 im))
(* -1 (log im))
(neg.f64 (log.f64 im))
(* -1 (log im))
(neg.f64 (log.f64 im))
(* -1 (log im))
(neg.f64 (log.f64 im))
(log (/ 1 im))
(neg.f64 (log.f64 im))
(log (/ 1 im))
(neg.f64 (log.f64 im))
(log (/ 1 im))
(neg.f64 (log.f64 im))
(log (/ 1 im))
(neg.f64 (log.f64 im))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64)))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64)))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64)))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(-.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal -1 binary64)))
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(* -1/2 (/ (log (pow re 2)) (log 1/10)))
(.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(.f64 #s(literal -1/2 binary64) (fma.f64 im (/.f64 im (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal -1/2 binary64) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64)))))) (.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 im (.f64 im (fma.f64 (.f64 im im) (fma.f64 #s(literal -1/6 binary64) (/.f64 (.f64 im im) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 1/10 binary64))))) (/.f64 #s(literal -1/2 binary64) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64))))))) (.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(-.f64 (/.f64 (.f64 (.f64 re re) #s(literal -1/2 binary64)) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (-.f64 (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal 1/4 binary64)) (.f64 (.f64 (.f64 im im) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(fma.f64 #s(literal -1/6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (-.f64 (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal 1/4 binary64)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal -1/6 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
(* -1/2 (/ (log (pow im 2)) (log 1/10)))
(.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(.f64 #s(literal -1/2 binary64) (fma.f64 re (/.f64 re (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 re (.f64 re (fma.f64 re (.f64 re (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 1/10 binary64))))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))))) (.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal -1/6 binary64) (/.f64 (.f64 re re) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 1/10 binary64))))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 1/10 binary64)))))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(-.f64 (/.f64 (.f64 (.f64 im im) #s(literal -1/2 binary64)) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(-.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64))))) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/4 binary64)) (.f64 (.f64 (.f64 re re) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(-.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal -1/6 binary64)) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re (*.f64 re (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64))))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re (.f64 re (log.f64 #s(literal 1/10 binary64))))) (fma.f64 #s(literal -1/6 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
(/ 2 (log (pow re 2)))
(/.f64 #s(literal 2 binary64) (log.f64 (*.f64 re re)))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ 1 (log (pow re 2)))))
(fma.f64 #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64)))) (/.f64 #s(literal 2 binary64) (log.f64 (*.f64 re re))))
(+ (* (pow im 2) (- (* (pow im 2) (+ (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2))) (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))
(fma.f64 (.f64 im im) (fma.f64 im (.f64 im (+.f64 (/.f64 #s(literal 1 binary64) (.f64 (.f64 (.f64 re re) (.f64 re re)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64)))) (/.f64 #s(literal 2 binary64) (.f64 (.f64 (.f64 re re) (.f64 re re)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64)))))) (/.f64 #s(literal -2 binary64) (.f64 (.f64 re re) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))))) (/.f64 #s(literal 2 binary64) (log.f64 (.f64 re re))))
(+ (* (pow im 2) (- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 2/3 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 2)))) (+ (* 2 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 3)))) (* 2 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 4)))))))) (+ (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))) (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 (+.f64 (/.f64 #s(literal 2/3 binary64) (.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64)))) (+.f64 (/.f64 #s(literal 2 binary64) (.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64)))) (/.f64 #s(literal 2 binary64) (.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 4 binary64)))))) (.f64 im (neg.f64 im)) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 (.f64 (.f64 re re) (.f64 re re)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64)))) (/.f64 #s(literal 2 binary64) (.f64 (.f64 (.f64 re re) (.f64 re re)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64)))))) (/.f64 #s(literal -2 binary64) (.f64 (.f64 re re) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))))) (/.f64 #s(literal 2 binary64) (log.f64 (*.f64 re re))))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))
(-.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 im))) (/.f64 (fma.f64 #s(literal 1/4 binary64) (neg.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal -1/4 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (.f64 (.f64 im im) (*.f64 im im))))
(- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (+ (* 1/6 (/ (pow re 6) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))))
(-.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (.f64 re re) (fma.f64 #s(literal 1/4 binary64) (neg.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal -1/4 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (log.f64 im)) (fma.f64 #s(literal -1/8 binary64) (neg.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 im) #s(literal 3 binary64)))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/6 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64))))) (neg.f64 (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 2 binary64)))) (/.f64 #s(literal -1 binary64) (log.f64 im))))))
(/ -1 (log (/ -1 im)))
(/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))
(-.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (/.f64 (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal -1/4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (.f64 (.f64 im im) (*.f64 im im))))
(- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (+ (* 1/6 (/ (pow re 6) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))))
(-.f64 (neg.f64 (/.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal -1/4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (/.f64 (.f64 re re) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/6 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (.f64 (*.f64 im im) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))
(/ 2 (log (pow im 2)))
(/.f64 #s(literal 2 binary64) (log.f64 (*.f64 im im)))
(+ (* -2 (/ (pow re 2) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ 1 (log (pow im 2)))))
(fma.f64 #s(literal -2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64)))) (/.f64 #s(literal 2 binary64) (log.f64 (*.f64 im im))))
(+ (* (pow re 2) (- (* (pow re 2) (+ (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2))) (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 1 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64)))) (/.f64 #s(literal 2 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64))))) (/.f64 #s(literal -2 binary64) (.f64 (.f64 im im) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))))) (/.f64 #s(literal 2 binary64) (log.f64 (.f64 im im))))
(+ (* (pow re 2) (- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 2/3 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 2)))) (+ (* 2 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 3)))) (* 2 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 4)))))))) (+ (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))) (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))
(fma.f64 re (.f64 re (fma.f64 (.f64 re re) (-.f64 (+.f64 (/.f64 #s(literal 1 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64)))) (/.f64 #s(literal 2 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64))))) (.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 2/3 binary64) (.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64)))) (+.f64 (/.f64 #s(literal 2 binary64) (.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64)))) (/.f64 #s(literal 2 binary64) (.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 4 binary64)))))))) (/.f64 #s(literal -2 binary64) (.f64 (.f64 im im) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64)))))) (/.f64 #s(literal 2 binary64) (log.f64 (.f64 im im))))
(/ -1 (log (/ 1 re)))
(/.f64 #s(literal 1 binary64) (log.f64 re))
(- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 re re) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 re)))
(- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))
(-.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 re))) (/.f64 (fma.f64 #s(literal 1/4 binary64) (neg.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal -1/4 binary64)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (.f64 (.f64 re re) (*.f64 re re))))
(- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (+ (* 1/6 (/ (pow im 6) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))))
(-.f64 (/.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im (.f64 im (fma.f64 #s(literal 1/4 binary64) (neg.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal -1/4 binary64)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))))) (neg.f64 (log.f64 re))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/6 binary64)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))))) (neg.f64 (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (neg.f64 (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (.f64 (.f64 re re) (.f64 re re))))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 re re) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)))) (/.f64 #s(literal -1 binary64) (log.f64 re))))))
(/ -1 (log (/ -1 re)))
(/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 re re) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))
(-.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (/.f64 (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal -1/4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (.f64 (.f64 re re) (*.f64 re re))))
(- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (+ (* 1/6 (/ (pow im 6) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))))
(-.f64 (/.f64 (fma.f64 #s(literal 1/2 binary64) (.f64 (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal -1/4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (/.f64 (.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal -1/8 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/6 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (neg.f64 (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (fma.f64 #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 re re) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))))))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64)))
(* -1 (log (/ (log 10) (log im))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (/ (log 10) (log im))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (/ (log 10) (log im))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (/ (log 10) (log im))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
(* -1 (log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
(log (/ (log 10) (log im)))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (/ (log 10) (log im)))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (/ (log 10) (log im)))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (/ (log 10) (log im)))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(log (/ (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(log (pow re 2))
(log.f64 (*.f64 re re))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(fma.f64 im (/.f64 im (.f64 re re)) (log.f64 (.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(fma.f64 (.f64 im im) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1 binary64) (.f64 re re))) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal 1 binary64) (.f64 re re))) (log.f64 (.f64 re re)))
(* -2 (log (/ 1 im)))
(*.f64 #s(literal 2 binary64) (log.f64 im))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 re (/.f64 re (.f64 im im)) (.f64 #s(literal 2 binary64) (log.f64 im)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 re (/.f64 re (.f64 im im)) (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal -1/2 binary64)) (.f64 (.f64 im im) (.f64 im im)))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/2 binary64) (fma.f64 re (/.f64 re (.f64 im im)) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/3 binary64)) (pow.f64 im #s(literal 6 binary64))))))
(* -2 (log (/ -1 im)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (/.f64 (.f64 re re) (.f64 im im)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/2 binary64) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (/.f64 (.f64 re re) (.f64 im im))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/2 binary64) (fma.f64 re (/.f64 re (.f64 im im)) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/3 binary64)) (pow.f64 im #s(literal 6 binary64))))))
(log (pow im 2))
(log.f64 (*.f64 im im))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(fma.f64 re (/.f64 re (.f64 im im)) (log.f64 (.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(fma.f64 (.f64 re re) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 (.f64 im im) (.f64 im im))) (/.f64 #s(literal 1 binary64) (.f64 im im))) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 im im) (.f64 im im)))) (/.f64 #s(literal 1 binary64) (.f64 im im))) (log.f64 (.f64 im im)))
(* -2 (log (/ 1 re)))
(*.f64 #s(literal 2 binary64) (log.f64 re))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 im (/.f64 im (.f64 re re)) (.f64 #s(literal 2 binary64) (log.f64 re)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 #s(literal 2 binary64) (log.f64 re) (fma.f64 im (/.f64 im (.f64 re re)) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal -1/2 binary64)) (.f64 (.f64 re re) (.f64 re re)))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (log.f64 re) (fma.f64 im (/.f64 im (.f64 re re)) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/2 binary64) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/3 binary64)) (pow.f64 re #s(literal 6 binary64))))))
(* -2 (log (/ -1 re)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 re re)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 im (/.f64 im (.f64 re re)) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/2 binary64) (.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (fma.f64 im (/.f64 im (.f64 re re)) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/2 binary64) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 1/3 binary64)) (pow.f64 re #s(literal 6 binary64))))))

eval388.0ms (4.2%)

Memory: -6.1MiB live, 248.4MiB allocated
Compiler: Compiled 29 448 to 3 725 computations (87.4% saved)

prune643.0ms (6.9%)

Memory

-170.5MiB live, 313.7MiB allocated

Pruning

21 alts after pruning (15 fresh and 6 done)

	Pruned	Kept	Total
New	1 497	9	1 506
Fresh	8	6	14
Picked	2	3	5
Done	0	3	3
Total	1 507	21	1 528

Accuracy

100.0%

Counts

1 528 → 21

Alt Table

Click to see full alt table

Status	Accuracy	Program
	74.5%	(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
	35.6%	(pow.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) #s(literal 2 binary64))
▶	28.9%	(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (-.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (log.f64 (-.f64 im re)))))
▶	97.9%	(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
	97.8%	(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
	97.8%	(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1 binary64)) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
	54.2%	(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
	97.9%	(/.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
▶	98.3%	(/.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) (log.f64 #s(literal 1/10 binary64)))
✓	97.8%	(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
✓	98.3%	(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	97.9%	(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
✓	97.9%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
	97.9%	(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
▶	97.8%	(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
	97.8%	(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
▶	97.4%	(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
	54.1%	(.f64 (.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
	97.8%	(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))

Compiler

Compiled 481 to 372 computations (22.7% saved)

simplify535.0ms (5.7%)

Memory

-25.1MiB live, 646.2MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score	Program
✓	cost-diff	0	(log.f64 #s(literal 1/10 binary64))
✓	cost-diff	0	(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
✓	cost-diff	1088	(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (-.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (log.f64 (-.f64 im re)))))
✓	cost-diff	1408	(/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))
✓	cost-diff	0	(/.f64 #s(literal 1 binary64) (log.f64 im))
✓	cost-diff	0	(log.f64 #s(literal 1/10 binary64))
✓	cost-diff	0	(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
✓	cost-diff	1280	(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
✓	cost-diff	0	(log.f64 im)
✓	cost-diff	0	(/.f64 #s(literal -1 binary64) (log.f64 im))
✓	cost-diff	192	(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
✓	cost-diff	704	(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
✓	cost-diff	0	(log.f64 im)
✓	cost-diff	0	(log.f64 #s(literal 10 binary64))
✓	cost-diff	0	(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
✓	cost-diff	320	(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
✓	cost-diff	0	(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
✓	cost-diff	0	(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
✓	cost-diff	0	(neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)))
✓	cost-diff	0	(/.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) (log.f64 #s(literal 1/10 binary64)))

Rules

19 030×	`lower-fma.f32`
19 026×	`lower-fma.f64`
4 174×	`lower-*.f32`
4 162×	`lower-*.f64`
2 698×	`lower-+.f32`

Iterations

Useful iterations: 3 (0.0ms)

Iter	Nodes	Cost
0	37	294
0	68	294
1	108	287
2	220	253
3	664	243
4	2050	243
5	5324	243
0	8417	243

Stop Event

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

Calls

Call 1

Inputs
(/.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)))
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
re
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(/.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
#s(literal 1 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 im)
im
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
#s(literal 1 binary64)
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
#s(literal -1 binary64)
(log.f64 im)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
#s(literal -1 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) (log.f64 im))
#s(literal 1 binary64)
(log.f64 im)
im
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (-.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (log.f64 (-.f64 im re)))))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
#s(literal -1 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 2 binary64) (-.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (log.f64 (-.f64 im re))))
#s(literal 2 binary64)
(-.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (log.f64 (-.f64 im re)))
(log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)))
(/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))
(.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))
(fma.f64 re re (*.f64 im im))
re
(*.f64 im im)
im
(*.f64 (+.f64 re im) (-.f64 im re))
(+.f64 re im)
(-.f64 im re)
(log.f64 (-.f64 im re))

Outputs
(/.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (/.f64 (log.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)))
(neg.f64 (log.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)))
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(log.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(fma.f64 #s(literal 1/2 binary64) (/.f64 (*.f64 re re) im) im)
re
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(/.f64 #s(literal 1/2 binary64) im)
#s(literal 1/2 binary64)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
#s(literal 1 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 im)
im
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
#s(literal 1 binary64)
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
#s(literal -1 binary64)
(log.f64 im)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (log.f64 im) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
#s(literal -1 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) (log.f64 im))
#s(literal 1 binary64)
(log.f64 im)
im
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (-.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (log.f64 (-.f64 im re)))))
(/.f64 (-.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) (log.f64 (-.f64 im re))) (*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64)))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
#s(literal -1 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 2 binary64) (-.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (log.f64 (-.f64 im re))))
(/.f64 #s(literal 2 binary64) (-.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) (log.f64 (-.f64 im re))))
#s(literal 2 binary64)
(-.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (log.f64 (-.f64 im re)))
(-.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) (log.f64 (-.f64 im re)))
(log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)))
(log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)))
(/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))
(.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))
(.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))
(fma.f64 re re (*.f64 im im))
re
(*.f64 im im)
im
(*.f64 (+.f64 re im) (-.f64 im re))
(+.f64 re im)
(-.f64 im re)
(log.f64 (-.f64 im re))

localize140.0ms (1.5%)

Memory

45.7MiB live, 316.1MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score	Program
✓	accuracy	98.4%	(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
✓	accuracy	98.4%	(log.f64 #s(literal 1/10 binary64))
✓	accuracy	91.0%	(/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))
✓	accuracy	38.8%	(log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)))
✓	accuracy	99.5%	(/.f64 #s(literal 1 binary64) (log.f64 im))
✓	accuracy	99.5%	(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
✓	accuracy	98.4%	(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
✓	accuracy	98.4%	(log.f64 #s(literal 1/10 binary64))
✓	accuracy	99.6%	(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
✓	accuracy	99.5%	(/.f64 #s(literal -1 binary64) (log.f64 im))
✓	accuracy	99.2%	(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
✓	accuracy	98.4%	(log.f64 #s(literal 1/10 binary64))
✓	accuracy	100.0%	(log.f64 im)
✓	accuracy	100.0%	(log.f64 #s(literal 10 binary64))
✓	accuracy	99.5%	(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
✓	accuracy	98.4%	(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
✓	accuracy	100.0%	(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
✓	accuracy	99.6%	(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
✓	accuracy	99.0%	(/.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) (log.f64 #s(literal 1/10 binary64)))
✓	accuracy	98.4%	(log.f64 #s(literal 1/10 binary64))

Samples

86.0ms

256×

valid

Compiler

Compiled 307 to 41 computations (86.6% saved)

Precisions

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

ival-div: 19.0ms (30.5% of total)

ival-log: 17.0ms (27.3% of total)

ival-mult: 15.0ms (24.1% of total)

const: 4.0ms (6.4% of total)

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

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

exact: 1.0ms (1.6% of total)

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

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

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

series83.0ms (0.9%)

Memory

-12.0MiB live, 150.9MiB allocated

Counts

19 → 276

Calls

Call 1

Inputs
#<alt (/.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) (log.f64 #s(literal 1/10 binary64)))>
#<alt (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)))>
#<alt (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))>
#<alt (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)>
#<alt (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))>
#<alt (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))>
#<alt (log.f64 #s(literal 10 binary64))>
#<alt (log.f64 im)>
#<alt (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))>
#<alt (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))>
#<alt (/.f64 #s(literal -1 binary64) (log.f64 im))>
#<alt (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))>
#<alt (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))>
#<alt (log.f64 #s(literal 1/10 binary64))>
#<alt (/.f64 #s(literal 1 binary64) (log.f64 im))>
#<alt (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))>
#<alt (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (-.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (log.f64 (-.f64 im re)))))>
#<alt (*.f64 re (/.f64 #s(literal 1/2 binary64) im))>
#<alt (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)))>

Outputs
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))>
#<alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/8 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/24 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/8 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10)))>
#<alt (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))))>
#<alt (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10))))))>
#<alt (+ (* -8/3 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10)))))))>
#<alt (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10)))>
#<alt (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))))>
#<alt (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10))))))>
#<alt (+ (* -8/3 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10)))))))>
#<alt (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10)))>
#<alt (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))))>
#<alt (+ (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))) (* (pow im 2) (- (* 2 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (+ (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -8/3 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 2 (/ 1 (* (pow re 4) (log 1/10)))))) (* 2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))>
#<alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/24 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))>
#<alt (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10))))))>
#<alt (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/24 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))))))>
#<alt (* -1 (log im))>
#<alt (- (* -1/2 (/ (pow re 2) (pow im 2))) (log im))>
#<alt (- (* (pow re 2) (- (* 1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im))>
#<alt (- (* (pow re 2) (- (* (pow re 2) (+ (* -1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))) (log im))>
#<alt (* -1 (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))))>
#<alt (- (* -2 (/ (pow im 2) (pow re 2))) (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))))>
#<alt (- (* 2 (/ (pow im 4) (pow re 4))) (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2))))))>
#<alt (- (* -8/3 (/ (pow im 6) (pow re 6))) (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))))>
#<alt (- (* -2 (/ (pow im 2) (pow re 2))) (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))))>
#<alt (- (* 2 (/ (pow im 4) (pow re 4))) (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2))))))>
#<alt (- (* -8/3 (/ (pow im 6) (pow re 6))) (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2)))))))>
#<alt (* -1 (+ (log (* 1/2 (pow re 2))) (* -1 (log im))))>
#<alt (- (* -2 (/ (pow im 2) (pow re 2))) (+ (log (* 1/2 (pow re 2))) (* -1 (log im))))>
#<alt (- (* (pow im 2) (- (* 2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2))))) (+ (log (* 1/2 (pow re 2))) (* -1 (log im))))>
#<alt (- (* (pow im 2) (- (* (pow im 2) (+ (* -8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2))))) (+ (log (* 1/2 (pow re 2))) (* -1 (log im))))>
#<alt (log (/ 1 im))>
#<alt (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))>
#<alt (- (* 1/8 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (- (* -1/24 (/ (pow re 6) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (* -1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (- (* -1/2 (/ (pow re 2) (pow im 2))) (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (- (* 1/8 (/ (pow re 4) (pow im 4))) (+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (- (* -1/24 (/ (pow re 6) (pow im 6))) (+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt (log im)>
#<alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))>
#<alt (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))>
#<alt (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))>
#<alt (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))>
#<alt (+ (log (* 1/2 (pow re 2))) (* -1 (log im)))>
#<alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2)))))>
#<alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2)))))))>
#<alt (+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2)))))))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))>
#<alt (+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))>
#<alt im>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (+ im (* 1/2 (/ (pow re 2) im)))>
#<alt (* 1/2 (/ (pow re 2) im))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* 1/2 (/ (pow re 2) im))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))>
#<alt (* 1/2 (/ (pow re 2) im))>
#<alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)>
#<alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)>
#<alt (/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)>
#<alt im>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))>
#<alt im>
#<alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))>
#<alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))>
#<alt (* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (/ (log im) (log 10))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (* -1 (/ (log (/ 1 im)) (log 10)))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (log im)>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (* -1 (log (/ 1 im)))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (+ (log -1) (* -1 (log (/ -1 im))))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (log 1/10) (log im)))>
#<alt (* -1 (/ (log 1/10) (log im)))>
#<alt (* -1 (/ (log 1/10) (log im)))>
#<alt (* -1 (/ (log 1/10) (log im)))>
#<alt (/ (log 1/10) (log (/ 1 im)))>
#<alt (/ (log 1/10) (log (/ 1 im)))>
#<alt (/ (log 1/10) (log (/ 1 im)))>
#<alt (/ (log 1/10) (log (/ 1 im)))>
#<alt (* -1 (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))))>
#<alt (* -1 (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))))>
#<alt (* -1 (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))))>
#<alt (* -1 (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))))>
#<alt (/ -1 (log im))>
#<alt (/ -1 (log im))>
#<alt (/ -1 (log im))>
#<alt (/ -1 (log im))>
#<alt (/ 1 (log (/ 1 im)))>
#<alt (/ 1 (log (/ 1 im)))>
#<alt (/ 1 (log (/ 1 im)))>
#<alt (/ 1 (log (/ 1 im)))>
#<alt (/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (* -1 (/ (log im) (log 1/10)))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (/ (log (/ 1 im)) (log 1/10))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (/ 1 (log im))>
#<alt (/ 1 (log im))>
#<alt (/ 1 (log im))>
#<alt (/ 1 (log im))>
#<alt (/ -1 (log (/ 1 im)))>
#<alt (/ -1 (log (/ 1 im)))>
#<alt (/ -1 (log (/ 1 im)))>
#<alt (/ -1 (log (/ 1 im)))>
#<alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))>
#<alt (pow im 3)>
#<alt (+ (* -1 (* (pow im 2) re)) (pow im 3))>
#<alt (+ (* re (+ (* -1 (pow im 2)) (* im re))) (pow im 3))>
#<alt (+ (* re (+ (* -1 (pow im 2)) (* re (+ im (* -1 re))))) (pow im 3))>
#<alt (* -1 (pow re 3))>
#<alt (* (pow re 3) (- (/ im re) 1))>
#<alt (* (pow re 3) (- (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re)) 1))>
#<alt (* (pow re 3) (- (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (/ im re) (/ (pow im 3) (pow re 3)))) 1))>
#<alt (* -1 (pow re 3))>
#<alt (* -1 (* (pow re 3) (+ 1 (* -1 (/ im re)))))>
#<alt (* -1 (* (pow re 3) (+ 1 (* -1 (/ (+ im (* -1 (/ (pow im 2) re))) re)))))>
#<alt (* -1 (* (pow re 3) (+ 1 (* -1 (/ (+ im (* -1 (/ (+ (* -1 (/ (pow im 3) re)) (pow im 2)) re))) re)))))>
#<alt (* -1 (pow re 3))>
#<alt (+ (* -1 (pow re 3)) (* im (pow re 2)))>
#<alt (+ (* -1 (pow re 3)) (* im (+ (* -1 (* im re)) (pow re 2))))>
#<alt (+ (* -1 (pow re 3)) (* im (+ (* im (+ im (* -1 re))) (pow re 2))))>
#<alt (pow im 3)>
#<alt (* (pow im 3) (+ 1 (* -1 (/ re im))))>
#<alt (* (pow im 3) (+ 1 (+ (* -1 (/ re im)) (/ (pow re 2) (pow im 2)))))>
#<alt (* (pow im 3) (+ 1 (+ (* -1 (/ re im)) (+ (* -1 (/ (pow re 3) (pow im 3))) (/ (pow re 2) (pow im 2))))))>
#<alt (pow im 3)>
#<alt (* -1 (* (pow im 3) (- (/ re im) 1)))>
#<alt (* -1 (* (pow im 3) (- (* -1 (/ (+ (* -1 re) (/ (pow re 2) im)) im)) 1)))>
#<alt (* -1 (* (pow im 3) (- (* -1 (/ (+ (* -1 re) (* -1 (/ (+ (* -1 (pow re 2)) (/ (pow re 3) im)) im))) im)) 1)))>
#<alt (* -1/2 (/ (- (log (pow im 3)) (log im)) (log 1/10)))>
#<alt (+ (* -1/2 (/ (- (log (pow im 3)) (log im)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))>
#<alt (+ (* -1/2 (/ (- (log (pow im 3)) (log im)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (+ (* -1/2 (/ (- (log (pow im 3)) (log im)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))>
#<alt (* -1/2 (/ (- (* -3 (log (/ 1 re))) (* -1 (log (/ 1 re)))) (log 1/10)))>
#<alt (+ (* -1/2 (/ (- (* -3 (log (/ 1 re))) (* -1 (log (/ 1 re)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2))))>
#<alt (+ (* -1/2 (/ (- (* -3 (log (/ 1 re))) (* -1 (log (/ 1 re)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* -2 (pow im 3)) (* 6 (pow im 3)))) (log 1/10))) (* -1/3 (/ (pow im 3) (log 1/10)))) (pow re 3))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2)))))>
#<alt (+ (* -1/2 (/ (- (* -3 (log (/ 1 re))) (* -1 (log (/ 1 re)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/24 (/ (+ (* -24 (pow im 4)) (+ (* -12 (pow im 4)) (+ (* -6 (pow im 4)) (* 24 (pow im 4))))) (log 1/10))) (* -1/4 (/ (pow im 4) (log 1/10)))) (pow re 4))) (+ (* -1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* -2 (pow im 3)) (* 6 (pow im 3)))) (log 1/10))) (* -1/3 (/ (pow im 3) (log 1/10)))) (pow re 3))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2))))))>
#<alt (* -1/2 (/ (- (* -3 (log (/ -1 re))) (* -1 (log (/ -1 re)))) (log 1/10)))>
#<alt (+ (* -1/2 (/ (- (* -3 (log (/ -1 re))) (* -1 (log (/ -1 re)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2))))>
#<alt (+ (* -1/2 (/ (- (* -3 (log (/ -1 re))) (* -1 (log (/ -1 re)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2))) (* 1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* 2 (pow im 3)) (* 6 (pow im 3)))) (log 1/10))) (* 1/3 (/ (pow im 3) (log 1/10)))) (pow re 3)))))>
#<alt (+ (* -1 (/ (+ (* -1/2 (- (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* 2 (pow im 3)) (* 6 (pow im 3)))) (log 1/10))) (* 1/3 (/ (pow im 3) (log 1/10))))) (* 1/2 (/ (- (* 1/24 (/ (+ (* -24 (pow im 4)) (+ (* -12 (pow im 4)) (+ (* -6 (pow im 4)) (* 24 (pow im 4))))) (log 1/10))) (* -1/4 (/ (pow im 4) (log 1/10)))) re))) (pow re 3))) (+ (* -1/2 (/ (- (* -3 (log (/ -1 re))) (* -1 (log (/ -1 re)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2)))))>
#<alt (* -1/2 (/ (- (log (* -1 (pow re 3))) (log (neg re))) (log 1/10)))>
#<alt (+ (* -1/2 (/ (- (log (* -1 (pow re 3))) (log (neg re))) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))>
#<alt (+ (* -1/2 (/ (- (log (* -1 (pow re 3))) (log (neg re))) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (+ (* -1/2 (/ (- (log (* -1 (pow re 3))) (log (neg re))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))>
#<alt (* -1/2 (/ (- (* -3 (log (/ 1 im))) (* -1 (log (/ 1 im)))) (log 1/10)))>
#<alt (+ (* -1/2 (/ (- (* -3 (log (/ 1 im))) (* -1 (log (/ 1 im)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2))))>
#<alt (+ (* -1/2 (/ (- (* -3 (log (/ 1 im))) (* -1 (log (/ 1 im)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* -2 (pow re 3)) (* 6 (pow re 3)))) (log 1/10))) (* -1/3 (/ (pow re 3) (log 1/10)))) (pow im 3))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2)))))>
#<alt (+ (* -1/2 (/ (- (* -3 (log (/ 1 im))) (* -1 (log (/ 1 im)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/24 (/ (+ (* -24 (pow re 4)) (+ (* -12 (pow re 4)) (+ (* -6 (pow re 4)) (* 24 (pow re 4))))) (log 1/10))) (* -1/4 (/ (pow re 4) (log 1/10)))) (pow im 4))) (+ (* -1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* -2 (pow re 3)) (* 6 (pow re 3)))) (log 1/10))) (* -1/3 (/ (pow re 3) (log 1/10)))) (pow im 3))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2))))))>
#<alt (* -1/2 (/ (- (* -3 (log (/ -1 im))) (* -1 (log (/ -1 im)))) (log 1/10)))>
#<alt (+ (* -1/2 (/ (- (* -3 (log (/ -1 im))) (* -1 (log (/ -1 im)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2))))>
#<alt (+ (* -1/2 (/ (- (* -3 (log (/ -1 im))) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2))) (* 1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* 2 (pow re 3)) (* 6 (pow re 3)))) (log 1/10))) (* 1/3 (/ (pow re 3) (log 1/10)))) (pow im 3)))))>
#<alt (+ (* -1 (/ (+ (* -1/2 (- (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* 2 (pow re 3)) (* 6 (pow re 3)))) (log 1/10))) (* 1/3 (/ (pow re 3) (log 1/10))))) (* 1/2 (/ (- (* 1/24 (/ (+ (* -24 (pow re 4)) (+ (* -12 (pow re 4)) (+ (* -6 (pow re 4)) (* 24 (pow re 4))))) (log 1/10))) (* -1/4 (/ (pow re 4) (log 1/10)))) im))) (pow im 3))) (+ (* -1/2 (/ (- (* -3 (log (/ -1 im))) (* -1 (log (/ -1 im)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2)))))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (* 1/2 (/ re im))>
#<alt (log (pow im 3))>
#<alt (+ (log (pow im 3)) (* -1 (/ re im)))>
#<alt (+ (log (pow im 3)) (* re (- (* 1/2 (/ re (pow im 2))) (/ 1 im))))>
#<alt (+ (log (pow im 3)) (* re (- (* re (+ (* -1/3 (/ re (pow im 3))) (* 1/2 (/ 1 (pow im 2))))) (/ 1 im))))>
#<alt (+ (log -1) (* -3 (log (/ 1 re))))>
#<alt (+ (log -1) (+ (* -3 (log (/ 1 re))) (* -1 (/ im re))))>
#<alt (+ (log -1) (+ (* -3 (log (/ 1 re))) (+ (* -1 (/ im re)) (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (pow re 2))))))>
#<alt (+ (log -1) (+ (* -3 (log (/ 1 re))) (+ (* -1 (/ im re)) (+ (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* -2 (pow im 3)) (* 6 (pow im 3)))) (pow re 3))) (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (pow re 2)))))))>
#<alt (* -3 (log (/ -1 re)))>
#<alt (+ (* -3 (log (/ -1 re))) (* -1 (/ im re)))>
#<alt (+ (* -3 (log (/ -1 re))) (* -1 (/ (+ im (* -1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) re))) re)))>
#<alt (+ (* -3 (log (/ -1 re))) (* -1 (/ (+ im (* -1 (/ (+ (* -1/6 (/ (+ (* -6 (pow im 3)) (+ (* 2 (pow im 3)) (* 6 (pow im 3)))) re)) (* 1/2 (+ (* -1 (pow im 2)) (* 2 (pow im 2))))) re))) re)))>
#<alt (log (* -1 (pow re 3)))>
#<alt (+ (log (* -1 (pow re 3))) (* -1 (/ im re)))>
#<alt (+ (log (* -1 (pow re 3))) (* im (- (* 1/2 (/ im (pow re 2))) (/ 1 re))))>
#<alt (+ (log (* -1 (pow re 3))) (* im (- (* im (+ (* -1/3 (/ im (pow re 3))) (* 1/2 (/ 1 (pow re 2))))) (/ 1 re))))>
#<alt (* -3 (log (/ 1 im)))>
#<alt (+ (* -3 (log (/ 1 im))) (* -1 (/ re im)))>
#<alt (+ (* -3 (log (/ 1 im))) (+ (* -1 (/ re im)) (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (pow im 2)))))>
#<alt (+ (* -3 (log (/ 1 im))) (+ (* -1 (/ re im)) (+ (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* -2 (pow re 3)) (* 6 (pow re 3)))) (pow im 3))) (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (pow im 2))))))>
#<alt (+ (log -1) (* -3 (log (/ -1 im))))>
#<alt (+ (log -1) (+ (* -3 (log (/ -1 im))) (* -1 (/ re im))))>
#<alt (+ (log -1) (+ (* -3 (log (/ -1 im))) (* -1 (/ (+ re (* -1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) im))) im))))>
#<alt (+ (log -1) (+ (* -3 (log (/ -1 im))) (* -1 (/ (+ re (* -1 (/ (+ (* -1/6 (/ (+ (* -6 (pow re 3)) (+ (* 2 (pow re 3)) (* 6 (pow re 3)))) im)) (* 1/2 (+ (* -1 (pow re 2)) (* 2 (pow re 2))))) im))) im))))>

Calls

69 calls:

Time	Variable		Point	Expression
49.0ms	re	@	inf	(/ (* (+ (* re re) (* im im)) (* (+ re im) (- im re))) (+ re im))
4.0ms	im	@	inf	(/ (/ -1 (log 1/10)) (/ 2 (- (log (/ (* (+ (* re re) (* im im)) (* (+ re im) (- im re))) (+ re im))) (log (- im re)))))
3.0ms	im	@	inf	(/ (* (+ (* re re) (* im im)) (* (+ re im) (- im re))) (+ re im))
2.0ms	re	@	0	(/ (/ -1 (log 1/10)) (/ 2 (- (log (/ (* (+ (* re re) (* im im)) (* (+ re im) (- im re))) (+ re im))) (log (- im re)))))
2.0ms	im	@	0	(/ (/ -1 (log 1/10)) (/ 2 (- (log (/ (* (+ (* re re) (* im im)) (* (+ re im) (- im re))) (+ re im))) (log (- im re)))))

rewrite286.0ms (3.1%)

Memory

-14.0MiB live, 590.8MiB allocated

Algorithm

1×	batch-egg-rewrite

Rules

4 610×	`lower-/.f32`
4 588×	`lower-/.f64`
3 782×	`lower-*.f32`
3 770×	`lower-*.f64`
3 274×	`lower-fma.f32`

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	37	167
0	68	162
1	240	127
2	1575	119
0	8295	119

Stop Event

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

Counts

19 → 629

Calls

Call 1

Inputs
(/.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)))
(log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(literal 10 binary64))
(log.f64 im)
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(log.f64 #s(literal 1/10 binary64))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (-.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (log.f64 (-.f64 im re)))))
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)))

Outputs
(+.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)) (log.f64 #s(literal 10 binary64))))
(exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 (log.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (log.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (log.f64 #s(literal 10 binary64))))
(neg.f64 (/.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im))))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im))))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)))) (log.f64 #s(literal 1/10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) (log.f64 #s(literal 1/10 binary64))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) (log.f64 #s(literal 1/10 binary64))) (.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)) (log.f64 #s(literal 1/10 binary64)))))))
(/.f64 (-.f64 #s(literal 0 binary64) (.f64 (/.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) (log.f64 #s(literal 1/10 binary64))))) (+.f64 #s(literal 0 binary64) (/.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) (log.f64 #s(literal 1/10 binary64)))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im))) #s(literal -1 binary64))
(.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal -1 binary64) (/.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) (log.f64 #s(literal 1/10 binary64))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 1 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))) #s(literal -1 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))) #s(literal -1 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal -1 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))) #s(literal 1 binary64)))
(.f64 (/.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (/.f64 (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im))) #s(literal -1/2 binary64)))
(log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)))
(+.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im))))
(+.f64 (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))))) (log.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))))
(+.f64 (log.f64 (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)))) (log.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)))
(-.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im))))
(-.f64 (/.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64)) #s(literal 0 binary64))) (/.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64)) #s(literal 0 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))) (/.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64)) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im))))
(neg.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64)) #s(literal 0 binary64)) (neg.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) (neg.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64)) #s(literal 0 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64))) (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (neg.f64 (neg.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64)))) (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64)) (.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)))))))
(.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal -1 binary64))
(.f64 (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))) #s(literal 1 binary64))
(.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)))
(.f64 (neg.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64)) #s(literal 0 binary64))))
(.f64 (neg.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im))))
(log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im))
(+.f64 #s(literal 0 binary64) (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)))
(+.f64 (log.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (log.f64 (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))))))
(+.f64 (log.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (neg.f64 (log.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))))))
(+.f64 (log.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))) (log.f64 (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))))
(+.f64 (log.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))) (neg.f64 (log.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im))))
(-.f64 (log.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (log.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))))
(-.f64 (log.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (log.f64 (fma.f64 im im (-.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 im (.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64)))))))))
(-.f64 (log.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))) (log.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)))
(-.f64 (log.f64 (neg.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))))) (log.f64 (neg.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))))))
(-.f64 (log.f64 (neg.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)))) (log.f64 (neg.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))))
(-.f64 (log.f64 (-.f64 (.f64 im im) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))) (log.f64 (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))))
(neg.f64 (neg.f64 (log.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im))))
(/.f64 (neg.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64))) (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))))
(/.f64 (+.f64 #s(literal 0 binary64) (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (-.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64)) #s(literal 0 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)) #s(literal 2 binary64)) (.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))) #s(literal 3 binary64))) (fma.f64 (log.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (log.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (fma.f64 (log.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))) (log.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))) (.f64 (log.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (log.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64)))))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) #s(literal 3 binary64))) (fma.f64 (log.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))) (log.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))) (fma.f64 (log.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (log.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (.f64 (log.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))) (log.f64 (-.f64 (.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64)))) im))))))
(/.f64 (-.f64 (.f64 (log.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (log.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))))) (.f64 (log.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))) (log.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))))) (+.f64 (log.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (log.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))))))
(/.f64 (-.f64 (.f64 (log.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))) (log.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)))) (.f64 (log.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (log.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)))) (+.f64 (log.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))) (log.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))))
(.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im)))
(.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))))
(+.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))
(+.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)
(+.f64 (/.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (neg.f64 (/.f64 (.f64 im im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))))
(-.f64 (/.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)))
(-.f64 (/.f64 (/.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) #s(literal 1 binary64)) (/.f64 (/.f64 (.f64 im im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) #s(literal 1 binary64)))
(-.f64 (/.f64 (.f64 im im) (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))) (/.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))))
(fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)
(fma.f64 im #s(literal 1 binary64) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(fma.f64 (/.f64 re (*.f64 im #s(literal 2 binary64))) re im)
(fma.f64 #s(literal -1 binary64) (neg.f64 im) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))
(fma.f64 (*.f64 re re) (/.f64 #s(literal 1/2 binary64) im) im)
(fma.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (neg.f64 (/.f64 (.f64 im im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))))
(fma.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (.f64 (.f64 re re) #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) im) im)
(fma.f64 (.f64 (.f64 re #s(literal 1/2 binary64)) re) (/.f64 #s(literal 1 binary64) im) im)
(fma.f64 (/.f64 re im) (/.f64 re #s(literal 2 binary64)) im)
(fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im)
(fma.f64 (/.f64 (*.f64 re re) #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) im) im)
(fma.f64 (pow.f64 im #s(literal 1/2 binary64)) (pow.f64 im #s(literal 1/2 binary64)) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))
(/.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 im im (-.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))) (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (*.f64 im im)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (-.f64 (.f64 im im) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im))))
(/.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))) (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))))
(/.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))) (fma.f64 im im (-.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 im (.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))))))))
(/.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))
(/.f64 (neg.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)) #s(literal -1 binary64))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (neg.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (neg.f64 (fma.f64 im im (-.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 im (.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64)))))))))
(/.f64 (neg.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))) (neg.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)))
(/.f64 (-.f64 (.f64 im im) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))) (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))
(/.f64 (-.f64 (.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im) (.f64 im im))) (.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im) (-.f64 (.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64)))) im)))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))))) (neg.f64 (neg.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))))))
(/.f64 (neg.f64 (neg.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)))) (neg.f64 (neg.f64 (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))))
(/.f64 (neg.f64 (-.f64 (.f64 im im) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))))) (neg.f64 (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) #s(literal 3 binary64)) (pow.f64 (/.f64 (.f64 im im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (/.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (fma.f64 (/.f64 (.f64 im im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (.f64 (/.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64)))) im))))))
(/.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (/.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))) (.f64 (/.f64 (.f64 im im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)))) (+.f64 (/.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (/.f64 (.f64 im im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))))
(pow.f64 (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))) im)) #s(literal -1 binary64))
(.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) #s(literal 1 binary64))
(.f64 #s(literal 1 binary64) (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im))
(.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64))))))))
(.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im))) (/.f64 #s(literal 1 binary64) (fma.f64 im im (-.f64 (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))))))
(.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im)) (/.f64 #s(literal 1 binary64) (-.f64 (.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64)))) im)))
(.f64 (neg.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 1/8 binary64) (.f64 im (.f64 im im))) (.f64 im (.f64 im im)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 im (-.f64 im (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))))) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64)))))))))
(.f64 (neg.f64 (.f64 (fma.f64 re (/.f64 re (.f64 im #s(literal 2 binary64))) im) (-.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) im))) (/.f64 #s(literal 1 binary64) (neg.f64 (-.f64 (.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64)))) im))))
(.f64 (-.f64 (.f64 im im) (.f64 (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))) (.f64 re (/.f64 re (.f64 im #s(literal 2 binary64)))))) (/.f64 #s(literal 1 binary64) (-.f64 im (.f64 re (/.f64 re (*.f64 im #s(literal 2 binary64)))))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(exp.f64 (-.f64 (.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)) (.f64 (log.f64 (log.f64 im)) #s(literal -1 binary64))))
(-.f64 #s(literal 0 binary64) (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im))) (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(pow.f64 (exp.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal -1 binary64) (.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 im)))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(.f64 (.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1 binary64))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(exp.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64))
(pow.f64 (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)))
(log.f64 #s(literal 10 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(exp.f64 (neg.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(log.f64 im)
(exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 #s(literal 1 binary64) (log.f64 im))) #s(literal -1 binary64)))
(exp.f64 (.f64 (.f64 (log.f64 (log.f64 im)) #s(literal -1 binary64)) #s(literal -1 binary64)))
(exp.f64 (neg.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal -1 binary64))))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 im)))
(neg.f64 (neg.f64 (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (log.f64 im) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (log.f64 im) #s(literal 1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 im))
(*.f64 (log.f64 im) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(*.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64))
(*.f64 (pow.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (log.f64 im) #s(literal 1/2 binary64)) (pow.f64 (log.f64 im) #s(literal 1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(exp.f64 (-.f64 (.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)) (.f64 (log.f64 (log.f64 im)) #s(literal -1 binary64))))
(-.f64 #s(literal 0 binary64) (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im))) (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(pow.f64 (exp.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal -1 binary64) (.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 im)))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(.f64 (.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1 binary64))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(exp.f64 (neg.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64))))
(exp.f64 (-.f64 (.f64 (log.f64 (log.f64 im)) #s(literal -1 binary64)) (.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(-.f64 #s(literal 0 binary64) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64)))
(-.f64 (/.f64 #s(literal 0 binary64) (neg.f64 (log.f64 im))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1 binary64)))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(/.f64 #s(literal -1 binary64) (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal -1 binary64)))
(*.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))) (/.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64))))
(+.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 im))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 im)) (*.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 im)))) (+.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal 1 binary64))
(pow.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal -1 binary64))
(*.f64 (pow.f64 (neg.f64 (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal -1/2 binary64)))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(exp.f64 (-.f64 (.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)) (.f64 (log.f64 (log.f64 im)) #s(literal -1 binary64))))
(-.f64 #s(literal 0 binary64) (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im))) (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1/2 binary64))
(pow.f64 (exp.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 #s(literal -1 binary64) (.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (log.f64 im)))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(.f64 (.f64 (log.f64 im) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1 binary64))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal 1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(*.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 im) #s(literal -1/2 binary64))))
(exp.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64))
(pow.f64 (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)))
(log.f64 #s(literal 1/10 binary64))
(+.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64)))
(neg.f64 (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (fma.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64)) (*.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))))))
(/.f64 (-.f64 #s(literal 0 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64)))) (log.f64 #s(literal 10 binary64)))
(*.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(neg.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) #s(literal -1 binary64))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 1 binary64))
(pow.f64 (log.f64 im) #s(literal -1 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 1 binary64))
(pow.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (*.f64 (log.f64 im) (log.f64 im)) #s(literal -1/2 binary64))
(pow.f64 (exp.f64 (log.f64 (log.f64 im))) #s(literal -1 binary64))
(*.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(*.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) #s(literal 1 binary64))
(*.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) (pow.f64 (log.f64 im) #s(literal -1/2 binary64)))
(exp.f64 (.f64 (neg.f64 (log.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re)))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (neg.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))))
(-.f64 (/.f64 #s(literal 0 binary64) (-.f64 (neg.f64 im) re)) (neg.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))))
(neg.f64 (neg.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))))
(/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (+.f64 re im)) (.f64 (fma.f64 (.f64 im im) (.f64 im (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re)))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (+.f64 re im)) (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (.f64 (fma.f64 (.f64 im im) (.f64 im (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 (.f64 re re) (*.f64 re re)))) (-.f64 im re))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 (+.f64 re im) (-.f64 re im)) (.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 re im))) (-.f64 im re))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)))))
(/.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (-.f64 im re)))
(/.f64 (-.f64 im re) (/.f64 #s(literal 1 binary64) (fma.f64 re re (*.f64 im im))))
(/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))
(/.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (neg.f64 (fma.f64 re re (*.f64 im im)))) (-.f64 (neg.f64 im) re))
(/.f64 (.f64 (fma.f64 (.f64 im im) (.f64 im (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re)))) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (+.f64 re im)))
(/.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (+.f64 re im) (-.f64 im re))) (.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (+.f64 re im)))
(/.f64 (.f64 (fma.f64 (.f64 im im) (.f64 im (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re)))) (-.f64 im re)) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))))
(/.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (-.f64 im re)) (*.f64 (+.f64 re im) (-.f64 re im)))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 im im) (.f64 im (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re)))) (.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (+.f64 re im))))
(/.f64 (neg.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (+.f64 re im))))
(/.f64 (neg.f64 (.f64 (fma.f64 (.f64 im im) (.f64 im (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re)))) (-.f64 im re))) (neg.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(/.f64 (neg.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (-.f64 im re))) (neg.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(pow.f64 (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal -1 binary64))
(.f64 #s(literal 1 binary64) (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re)))
(.f64 #s(literal -1 binary64) (neg.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))))
(.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))))))
(.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))
(.f64 (-.f64 im re) (fma.f64 re re (.f64 im im)))
(.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (+.f64 re im)))
(.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (neg.f64 (fma.f64 re re (.f64 im im)))) (/.f64 #s(literal -1 binary64) (+.f64 re im)))
(.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))))
(.f64 (/.f64 #s(literal 1 binary64) (+.f64 re im)) (pow.f64 (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal -1 binary64)))
(.f64 (.f64 (+.f64 re im) (-.f64 im re)) (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im)))
(.f64 (.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im)) (/.f64 (-.f64 im re) (+.f64 re im)))
(.f64 (.f64 (fma.f64 (.f64 im im) (.f64 im (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re)))) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))) (+.f64 re im))))
(.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (+.f64 re im) (-.f64 im re))) (/.f64 #s(literal 1 binary64) (.f64 (.f64 (+.f64 re im) (-.f64 re im)) (+.f64 re im))))
(.f64 (.f64 (fma.f64 (.f64 im im) (.f64 im (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re)))) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))
(.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (.f64 (+.f64 re im) (-.f64 re im))))
(.f64 (.f64 (/.f64 (-.f64 im re) (fma.f64 im (-.f64 im re) (.f64 re re))) #s(literal 1 binary64)) (/.f64 (fma.f64 re re (.f64 im im)) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(.f64 (.f64 #s(literal 1 binary64) (/.f64 (-.f64 im re) (-.f64 re im))) (/.f64 (fma.f64 re re (*.f64 im im)) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (.f64 (/.f64 (fma.f64 re re (.f64 im im)) (fma.f64 im (-.f64 im re) (.f64 re re))) (-.f64 im re)) (fma.f64 im (-.f64 im re) (*.f64 re re)))
(.f64 (.f64 (/.f64 (fma.f64 re re (.f64 im im)) (fma.f64 im (-.f64 im re) (.f64 re re))) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(.f64 (.f64 (-.f64 im re) (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 re im))) (-.f64 re im))
(.f64 (.f64 (-.f64 im re) (/.f64 (fma.f64 re re (*.f64 im im)) (-.f64 re im))) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (/.f64 (fma.f64 re re (.f64 im im)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (/.f64 (.f64 (+.f64 re im) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(.f64 (/.f64 (fma.f64 re re (.f64 im im)) #s(literal -1 binary64)) (/.f64 (neg.f64 (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)))
(.f64 (/.f64 (.f64 (+.f64 re im) (-.f64 im re)) #s(literal -1 binary64)) (/.f64 (neg.f64 (fma.f64 re re (*.f64 im im))) (+.f64 re im)))
(.f64 (/.f64 (.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im)) #s(literal -1 binary64)) (/.f64 (neg.f64 (-.f64 im re)) (+.f64 re im)))
(.f64 (/.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 (+.f64 re im) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (+.f64 re im)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (/.f64 (-.f64 im re) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (+.f64 re im)) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (-.f64 im re) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (/.f64 (+.f64 re im) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(.f64 (/.f64 (+.f64 re im) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (/.f64 (-.f64 im re) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (+.f64 re im)) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(.f64 (/.f64 (-.f64 im re) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (+.f64 re im)) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (fma.f64 re (.f64 re re) (.f64 im (.f64 im im)))) (/.f64 (+.f64 re im) (/.f64 #s(literal 1 binary64) (fma.f64 im (-.f64 im re) (*.f64 re re)))))
(.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (.f64 (+.f64 re im) (-.f64 re im))) (/.f64 (+.f64 re im) (/.f64 #s(literal 1 binary64) (-.f64 re im))))
(.f64 (/.f64 (neg.f64 (.f64 (+.f64 re im) (-.f64 im re))) #s(literal -1 binary64)) (/.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im)))
(.f64 (/.f64 (neg.f64 (fma.f64 re re (.f64 im im))) #s(literal -1 binary64)) (-.f64 im re))
(.f64 (/.f64 (neg.f64 (.f64 (fma.f64 re re (*.f64 im im)) (+.f64 re im))) #s(literal -1 binary64)) (/.f64 (-.f64 im re) (+.f64 re im)))
(.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (+.f64 re im)) (/.f64 (-.f64 im re) (-.f64 re im)))
(.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))) #s(literal -1/2 binary64)))
(+.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)))) (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (neg.f64 (log.f64 (-.f64 im re)))))
(+.f64 (/.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))))
(exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))) #s(literal -1 binary64)))
(-.f64 #s(literal 0 binary64) (.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64))))
(-.f64 (/.f64 (.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (log.f64 (-.f64 im re)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64))))
(fma.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (neg.f64 (log.f64 (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) (.f64 (/.f64 #s(literal -1 binary64) (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (neg.f64 (log.f64 (-.f64 im re)))))
(neg.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(/.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 #s(literal 2 binary64) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (.f64 #s(literal 2 binary64) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re)))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 2 binary64))) (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im)))))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))))
(/.f64 #s(literal -1 binary64) (/.f64 (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (.f64 im im)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(/.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))
(/.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64)))) (.f64 #s(literal 2 binary64) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)))))
(/.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im))))) (.f64 #s(literal 2 binary64) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re)))))
(/.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64)))) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))) #s(literal 2 binary64))))
(/.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im))))) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))))
(/.f64 (neg.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (neg.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (.f64 im im))))) #s(literal -2 binary64))
(/.f64 (neg.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64))))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))))) (neg.f64 (.f64 #s(literal 2 binary64) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im)))))) (neg.f64 (.f64 #s(literal 2 binary64) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))))))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))))) (neg.f64 (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)))))
(/.f64 (neg.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im)))))) (neg.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re)))))
(/.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal 2 binary64))
(/.f64 (+.f64 (pow.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (neg.f64 (log.f64 (-.f64 im re)))) #s(literal 3 binary64))) (fma.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)))) (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)))) (-.f64 (.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (neg.f64 (log.f64 (-.f64 im re)))) (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (neg.f64 (log.f64 (-.f64 im re))))) (.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)))) (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (neg.f64 (log.f64 (-.f64 im re))))))))
(/.f64 (+.f64 (pow.f64 (/.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (/.f64 (neg.f64 (log.f64 (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64))) (fma.f64 (/.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))) (-.f64 (.f64 (/.f64 (neg.f64 (log.f64 (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))))) (.f64 (/.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))))))))
(/.f64 (-.f64 (.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)))) (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))))) (.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (neg.f64 (log.f64 (-.f64 im re)))) (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (neg.f64 (log.f64 (-.f64 im re)))))) (-.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)))) (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (neg.f64 (log.f64 (-.f64 im re))))))
(/.f64 (-.f64 (.f64 (/.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))))) (.f64 (/.f64 (neg.f64 (log.f64 (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))))) (-.f64 (/.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (neg.f64 (log.f64 (-.f64 im re))) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))))))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #s(literal -1 binary64))
(.f64 #s(literal 1/2 binary64) (pow.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))))
(.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))))
(.f64 #s(literal 1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 #s(literal 1/2 binary64) (/.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))))
(.f64 #s(literal 1 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64)))))
(.f64 #s(literal -1 binary64) (.f64 (log.f64 (fma.f64 re re (.f64 im im))) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64))))
(.f64 #s(literal -1 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))))
(.f64 #s(literal -1 binary64) (/.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))))
(.f64 (log.f64 (fma.f64 re re (.f64 im im))) (/.f64 #s(literal -1 binary64) (*.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(.f64 #s(literal -1/2 binary64) (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))))
(.f64 #s(literal -1/2 binary64) (pow.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64)))
(.f64 #s(literal -1/2 binary64) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64)))
(.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (neg.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1 binary64)))
(.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (log.f64 (fma.f64 re re (*.f64 im im))))
(.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (.f64 #s(literal 2 binary64) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 2 binary64))))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im))))) (/.f64 #s(literal 1 binary64) (.f64 #s(literal 2 binary64) (log.f64 (.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re)) (-.f64 im re))))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal -1/2 binary64))
(.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)))))
(.f64 (.f64 (/.f64 #s(literal -1 binary64) (.f64 #s(literal 2 binary64) (log.f64 #s(literal 1/10 binary64)))) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 (.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re)) (-.f64 im re)))))
(.f64 (neg.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64)) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))))
(.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (*.f64 im im)))) #s(literal 1/2 binary64))
(.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal 1 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))))) (/.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64)) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)))))
(.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im)))))) (/.f64 (.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) #s(literal -1/2 binary64)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re)))))
(.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal -2 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal 2 binary64)))
(.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)))))
(.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal 2 binary64) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im)))))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re)) (-.f64 im re)))))
(.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 2 binary64) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)))))
(.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 2 binary64) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im)))))) (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re)) (-.f64 im re)))))
(.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)))))
(.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 2 binary64) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im)))))) (/.f64 #s(literal 1 binary64) (log.f64 (.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re)) (-.f64 im re)))))
(.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))))) (/.f64 #s(literal -1 binary64) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)))))
(.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im)))))) (/.f64 #s(literal -1 binary64) (log.f64 (.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re)) (-.f64 im re)))))
(.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 2 binary64) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)))))
(.f64 (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (/.f64 #s(literal 2 binary64) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im)))))) (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (log.f64 (.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re)) (-.f64 im re)))))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1 binary64)))
(.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (.f64 im im))))
(.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(.f64 (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (.f64 im im))))
(.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))) #s(literal 1 binary64)))
(.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))))) (/.f64 #s(literal 1/2 binary64) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)))))
(.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1 binary64) (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im)))))) (/.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re)) (-.f64 im re)))))
(.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))) #s(literal -1/2 binary64)))
(/.f64 re (*.f64 im #s(literal 2 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 im (*.f64 re #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (*.f64 im #s(literal 2 binary64)) re))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (neg.f64 im) (*.f64 re #s(literal -1/2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (neg.f64 im) (*.f64 #s(literal -1/2 binary64) re)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 re) (neg.f64 (*.f64 im #s(literal 2 binary64))))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(/.f64 (neg.f64 (*.f64 re #s(literal 1/2 binary64))) (neg.f64 im))
(/.f64 (*.f64 re #s(literal -1/2 binary64)) (neg.f64 im))
(/.f64 (*.f64 #s(literal -1/2 binary64) re) (neg.f64 im))
(/.f64 (neg.f64 (neg.f64 (*.f64 re #s(literal 1/2 binary64)))) im)
(/.f64 (neg.f64 (*.f64 re #s(literal -1/2 binary64))) im)
(/.f64 (neg.f64 (*.f64 #s(literal -1/2 binary64) re)) im)
(pow.f64 (/.f64 im (*.f64 re #s(literal 1/2 binary64))) #s(literal -1 binary64))
(*.f64 re (/.f64 #s(literal 1/2 binary64) im))
(.f64 #s(literal 1/2 binary64) (.f64 (/.f64 #s(literal 1 binary64) im) re))
(*.f64 #s(literal 1/2 binary64) (/.f64 re im))
(*.f64 (/.f64 #s(literal 1/2 binary64) im) re)
(.f64 #s(literal 1 binary64) (/.f64 re (.f64 im #s(literal 2 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) im) (/.f64 re #s(literal 2 binary64)))
(.f64 (.f64 re #s(literal 1/2 binary64)) (/.f64 #s(literal 1 binary64) im))
(.f64 (neg.f64 (.f64 re #s(literal 1/2 binary64))) (/.f64 #s(literal -1 binary64) im))
(.f64 (.f64 re #s(literal -1/2 binary64)) (/.f64 #s(literal -1 binary64) im))
(.f64 (.f64 #s(literal -1/2 binary64) re) (/.f64 #s(literal -1 binary64) im))
(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
(*.f64 (/.f64 re #s(literal -1 binary64)) (/.f64 #s(literal -1/2 binary64) im))
(log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)))
(+.f64 (log.f64 (-.f64 im re)) (log.f64 (fma.f64 re re (*.f64 im im))))
(+.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 (-.f64 im re)))
(+.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (log.f64 (+.f64 re im))))
(+.f64 #s(literal 0 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))))
(+.f64 (log.f64 (.f64 (+.f64 re im) (-.f64 im re))) (log.f64 (/.f64 (fma.f64 re re (.f64 im im)) (+.f64 re im))))
(+.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (+.f64 re im))) (log.f64 (/.f64 (-.f64 im re) (+.f64 re im))))
(+.f64 (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (neg.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 (/.f64 #s(literal -1 binary64) (+.f64 re im))))
(+.f64 (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (neg.f64 (fma.f64 re re (*.f64 im im))))) (neg.f64 (log.f64 (-.f64 (neg.f64 im) re))))
(+.f64 (neg.f64 (log.f64 (+.f64 re im))) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(+.f64 (log.f64 (.f64 (/.f64 (fma.f64 re re (.f64 im im)) (fma.f64 im (-.f64 im re) (.f64 re re))) (-.f64 im re))) (log.f64 (fma.f64 im (-.f64 im re) (.f64 re re))))
(+.f64 (log.f64 (.f64 (-.f64 im re) (/.f64 (fma.f64 re re (.f64 im im)) (-.f64 re im)))) (log.f64 (-.f64 re im)))
(-.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (+.f64 re im)))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)))))
(-.f64 (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (neg.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 (-.f64 (neg.f64 im) re)))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 (/.f64 #s(literal 1 binary64) (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))))))
(-.f64 (log.f64 (.f64 (fma.f64 (.f64 im im) (.f64 im (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re)))) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re)))) (+.f64 re im))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (.f64 (*.f64 (+.f64 re im) (-.f64 re im)) (+.f64 re im))))
(-.f64 (log.f64 (.f64 (fma.f64 (.f64 im im) (.f64 im (.f64 im (.f64 im im))) (.f64 (.f64 re re) (.f64 (.f64 re re) (.f64 re re)))) (-.f64 im re))) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (*.f64 (+.f64 re im) (-.f64 im re))))))
(-.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 re im))) (-.f64 im re))) (log.f64 (*.f64 (+.f64 re im) (-.f64 re im))))
(-.f64 (/.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (+.f64 re im)) #s(literal 2 binary64)) (.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (+.f64 re im)))))) (/.f64 (pow.f64 (log.f64 (+.f64 re im)) #s(literal 3 binary64)) (+.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (+.f64 re im)) #s(literal 2 binary64)) (.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (+.f64 re im)))))))
(-.f64 (/.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)))) (/.f64 (pow.f64 (log.f64 (+.f64 re im)) #s(literal 2 binary64)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)))))
(fma.f64 #s(literal 1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 (-.f64 im re)))
(fma.f64 #s(literal -1 binary64) (log.f64 (+.f64 re im)) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (fma.f64 re re (*.f64 im im)))) (log.f64 (-.f64 im re)))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (-.f64 im re))) (log.f64 (fma.f64 re re (*.f64 im im))))
(fma.f64 (log.f64 (fma.f64 re re (*.f64 im im))) #s(literal 1 binary64) (log.f64 (-.f64 im re)))
(fma.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)))) (log.f64 (-.f64 im re)))
(fma.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 (-.f64 im re)) #s(literal 2 binary64)) (.f64 (log.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))) (neg.f64 (log.f64 (-.f64 im re))))))) (log.f64 (-.f64 im re)))
(fma.f64 (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im)))) (/.f64 #s(literal 1 binary64) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re)))) (log.f64 (-.f64 im re)))
(fma.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64)))) (/.f64 #s(literal 1 binary64) (neg.f64 (fma.f64 (log.f64 (-.f64 im re)) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (pow.f64 (log.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))) #s(literal 2 binary64))))) (log.f64 (-.f64 im re)))
(fma.f64 (neg.f64 (.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))) (log.f64 (fma.f64 re re (.f64 im im))))) (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)) (-.f64 im re))))) (log.f64 (-.f64 im re)))
(neg.f64 (neg.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)))))
(/.f64 #s(literal 1 binary64) (/.f64 (+.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (+.f64 re im)) #s(literal 2 binary64)) (.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (+.f64 re im))))) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (+.f64 re im)) #s(literal 3 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (+.f64 re im)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (+.f64 re im)) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (+.f64 re im)) #s(literal 2 binary64)) (.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (+.f64 re im))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (+.f64 re im)) #s(literal 2 binary64))) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (+.f64 re im)) #s(literal 3 binary64)))) (neg.f64 (+.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (+.f64 re im)) #s(literal 2 binary64)) (.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (+.f64 re im)))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (+.f64 re im)) #s(literal 2 binary64)))) (neg.f64 (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)))))
(/.f64 (+.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (neg.f64 (log.f64 (+.f64 re im))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (-.f64 (.f64 (neg.f64 (log.f64 (+.f64 re im))) (neg.f64 (log.f64 (+.f64 re im)))) (.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (log.f64 (+.f64 re im)))))))
(/.f64 (+.f64 (pow.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 3 binary64))) (fma.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 (fma.f64 re re (.f64 im im))) (-.f64 (pow.f64 (log.f64 (-.f64 im re)) #s(literal 2 binary64)) (.f64 (log.f64 (fma.f64 re re (*.f64 im im))) (log.f64 (-.f64 im re))))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (neg.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re)))) #s(literal 3 binary64))) (+.f64 #s(literal 0 binary64) (+.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 2 binary64)) (.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re))))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (neg.f64 (fma.f64 re re (.f64 im im))))) #s(literal 3 binary64)) (pow.f64 (log.f64 (-.f64 (neg.f64 im) re)) #s(literal 3 binary64))) (fma.f64 (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (neg.f64 (fma.f64 re re (.f64 im im))))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (neg.f64 (fma.f64 re re (.f64 im im))))) (fma.f64 (log.f64 (-.f64 (neg.f64 im) re)) (log.f64 (-.f64 (neg.f64 im) re)) (.f64 (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (neg.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 (-.f64 (neg.f64 im) re))))))
(/.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (.f64 (neg.f64 (log.f64 (+.f64 re im))) (neg.f64 (log.f64 (+.f64 re im))))) (-.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (neg.f64 (log.f64 (+.f64 re im)))))
(/.f64 (-.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 (fma.f64 re re (.f64 im im)))) (pow.f64 (log.f64 (-.f64 im re)) #s(literal 2 binary64))) (-.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 (-.f64 im re))))
(/.f64 (-.f64 #s(literal 0 binary64) (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))) #s(literal 2 binary64))) (+.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (-.f64 im re))))))
(/.f64 (-.f64 (.f64 (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (neg.f64 (fma.f64 re re (.f64 im im))))) (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (neg.f64 (fma.f64 re re (.f64 im im)))))) (.f64 (log.f64 (-.f64 (neg.f64 im) re)) (log.f64 (-.f64 (neg.f64 im) re)))) (+.f64 (log.f64 (.f64 (.f64 (+.f64 re im) (-.f64 im re)) (neg.f64 (fma.f64 re re (*.f64 im im))))) (log.f64 (-.f64 (neg.f64 im) re))))
(.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (.f64 (fma.f64 re re (*.f64 im im)) (-.f64 im re)))))
(.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 3 binary64)) (pow.f64 (log.f64 (+.f64 re im)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (+.f64 (pow.f64 (log.f64 (+.f64 re im)) #s(literal 2 binary64)) (.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re)))) (log.f64 (+.f64 re im)))))))
(.f64 (-.f64 (pow.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re)))) #s(literal 2 binary64)) (pow.f64 (log.f64 (+.f64 re im)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 (.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im)))))

simplify412.0ms (4.4%)

Memory

8.4MiB live, 723.9MiB allocated

Algorithm

1×	egg-herbie

Rules

10 054×	`lower-fma.f64`
10 054×	`lower-fma.f32`
5 414×	`lower-*.f64`
5 414×	`lower-*.f32`
3 556×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	648	4625
1	1887	4286
2	6007	4239
0	8115	4051

Stop Event

1×	iter limit
1×	node limit

Counts

276 → 273

Calls

Call 1

Inputs
(* -1 (/ (log im) (log 1/10)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/8 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/24 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/8 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10)))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10))))))
(+ (* -8/3 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10)))))))
(* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10)))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10))))))
(+ (* -8/3 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10)))))))
(* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10)))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))))
(+ (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))) (* (pow im 2) (- (* 2 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -8/3 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 2 (/ 1 (* (pow re 4) (log 1/10)))))) (* 2 (/ 1 (* (pow re 2) (log 1/10)))))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/24 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10))))))
(+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/24 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))))))
(* -1 (log im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (log im))
(- (* (pow re 2) (- (* 1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im))
(- (* (pow re 2) (- (* (pow re 2) (+ (* -1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))) (log im))
(* -1 (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))))
(- (* -2 (/ (pow im 2) (pow re 2))) (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))))
(- (* 2 (/ (pow im 4) (pow re 4))) (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2))))))
(- (* -8/3 (/ (pow im 6) (pow re 6))) (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2)))))))
(* -1 (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))))
(- (* -2 (/ (pow im 2) (pow re 2))) (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))))
(- (* 2 (/ (pow im 4) (pow re 4))) (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2))))))
(- (* -8/3 (/ (pow im 6) (pow re 6))) (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2)))))))
(* -1 (+ (log (* 1/2 (pow re 2))) (* -1 (log im))))
(- (* -2 (/ (pow im 2) (pow re 2))) (+ (log (* 1/2 (pow re 2))) (* -1 (log im))))
(- (* (pow im 2) (- (* 2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2))))) (+ (log (* 1/2 (pow re 2))) (* -1 (log im))))
(- (* (pow im 2) (- (* (pow im 2) (+ (* -8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2))))) (+ (log (* 1/2 (pow re 2))) (* -1 (log im))))
(log (/ 1 im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))
(- (* 1/8 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(- (* -1/24 (/ (pow re 6) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (+ (log -1) (* -1 (log (/ -1 im)))))
(- (* 1/8 (/ (pow re 4) (pow im 4))) (+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(- (* -1/24 (/ (pow re 6) (pow im 6))) (+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log (/ 1/2 im)) (* -2 (log (/ 1 re))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+ (log (/ 1/2 im)) (* -2 (log (/ -1 re))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+ (log (* 1/2 (pow re 2))) (* -1 (log im)))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2)))))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2)))))))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2)))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* 1/2 (/ (pow re 2) im)))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(* 1/2 (/ (pow re 2) im))
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(/ (log im) (log 10))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(log im)
(log im)
(log im)
(log im)
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (log 1/10) (log im)))
(* -1 (/ (log 1/10) (log im)))
(* -1 (/ (log 1/10) (log im)))
(* -1 (/ (log 1/10) (log im)))
(/ (log 1/10) (log (/ 1 im)))
(/ (log 1/10) (log (/ 1 im)))
(/ (log 1/10) (log (/ 1 im)))
(/ (log 1/10) (log (/ 1 im)))
(* -1 (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))))
(* -1 (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))))
(* -1 (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))))
(* -1 (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))))
(/ -1 (log im))
(/ -1 (log im))
(/ -1 (log im))
(/ -1 (log im))
(/ 1 (log (/ 1 im)))
(/ 1 (log (/ 1 im)))
(/ 1 (log (/ 1 im)))
(/ 1 (log (/ 1 im)))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(* -1 (/ (log im) (log 1/10)))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(/ (log (/ 1 im)) (log 1/10))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/ 1 (log im))
(/ 1 (log im))
(/ 1 (log im))
(/ 1 (log im))
(/ -1 (log (/ 1 im)))
(/ -1 (log (/ 1 im)))
(/ -1 (log (/ 1 im)))
(/ -1 (log (/ 1 im)))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(pow im 3)
(+ (* -1 (* (pow im 2) re)) (pow im 3))
(+ (* re (+ (* -1 (pow im 2)) (* im re))) (pow im 3))
(+ (* re (+ (* -1 (pow im 2)) (* re (+ im (* -1 re))))) (pow im 3))
(* -1 (pow re 3))
(* (pow re 3) (- (/ im re) 1))
(* (pow re 3) (- (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re)) 1))
(* (pow re 3) (- (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (/ im re) (/ (pow im 3) (pow re 3)))) 1))
(* -1 (pow re 3))
(* -1 (* (pow re 3) (+ 1 (* -1 (/ im re)))))
(* -1 (* (pow re 3) (+ 1 (* -1 (/ (+ im (* -1 (/ (pow im 2) re))) re)))))
(* -1 (* (pow re 3) (+ 1 (* -1 (/ (+ im (* -1 (/ (+ (* -1 (/ (pow im 3) re)) (pow im 2)) re))) re)))))
(* -1 (pow re 3))
(+ (* -1 (pow re 3)) (* im (pow re 2)))
(+ (* -1 (pow re 3)) (* im (+ (* -1 (* im re)) (pow re 2))))
(+ (* -1 (pow re 3)) (* im (+ (* im (+ im (* -1 re))) (pow re 2))))
(pow im 3)
(* (pow im 3) (+ 1 (* -1 (/ re im))))
(* (pow im 3) (+ 1 (+ (* -1 (/ re im)) (/ (pow re 2) (pow im 2)))))
(* (pow im 3) (+ 1 (+ (* -1 (/ re im)) (+ (* -1 (/ (pow re 3) (pow im 3))) (/ (pow re 2) (pow im 2))))))
(pow im 3)
(* -1 (* (pow im 3) (- (/ re im) 1)))
(* -1 (* (pow im 3) (- (* -1 (/ (+ (* -1 re) (/ (pow re 2) im)) im)) 1)))
(* -1 (* (pow im 3) (- (* -1 (/ (+ (* -1 re) (* -1 (/ (+ (* -1 (pow re 2)) (/ (pow re 3) im)) im))) im)) 1)))
(* -1/2 (/ (- (log (pow im 3)) (log im)) (log 1/10)))
(+ (* -1/2 (/ (- (log (pow im 3)) (log im)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1/2 (/ (- (log (pow im 3)) (log im)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1/2 (/ (- (log (pow im 3)) (log im)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(* -1/2 (/ (- (* -3 (log (/ 1 re))) (* -1 (log (/ 1 re)))) (log 1/10)))
(+ (* -1/2 (/ (- (* -3 (log (/ 1 re))) (* -1 (log (/ 1 re)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2))))
(+ (* -1/2 (/ (- (* -3 (log (/ 1 re))) (* -1 (log (/ 1 re)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* -2 (pow im 3)) (* 6 (pow im 3)))) (log 1/10))) (* -1/3 (/ (pow im 3) (log 1/10)))) (pow re 3))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2)))))
(+ (* -1/2 (/ (- (* -3 (log (/ 1 re))) (* -1 (log (/ 1 re)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/24 (/ (+ (* -24 (pow im 4)) (+ (* -12 (pow im 4)) (+ (* -6 (pow im 4)) (* 24 (pow im 4))))) (log 1/10))) (* -1/4 (/ (pow im 4) (log 1/10)))) (pow re 4))) (+ (* -1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* -2 (pow im 3)) (* 6 (pow im 3)))) (log 1/10))) (* -1/3 (/ (pow im 3) (log 1/10)))) (pow re 3))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2))))))
(* -1/2 (/ (- (* -3 (log (/ -1 re))) (* -1 (log (/ -1 re)))) (log 1/10)))
(+ (* -1/2 (/ (- (* -3 (log (/ -1 re))) (* -1 (log (/ -1 re)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2))))
(+ (* -1/2 (/ (- (* -3 (log (/ -1 re))) (* -1 (log (/ -1 re)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2))) (* 1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* 2 (pow im 3)) (* 6 (pow im 3)))) (log 1/10))) (* 1/3 (/ (pow im 3) (log 1/10)))) (pow re 3)))))
(+ (* -1 (/ (+ (* -1/2 (- (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* 2 (pow im 3)) (* 6 (pow im 3)))) (log 1/10))) (* 1/3 (/ (pow im 3) (log 1/10))))) (* 1/2 (/ (- (* 1/24 (/ (+ (* -24 (pow im 4)) (+ (* -12 (pow im 4)) (+ (* -6 (pow im 4)) (* 24 (pow im 4))))) (log 1/10))) (* -1/4 (/ (pow im 4) (log 1/10)))) re))) (pow re 3))) (+ (* -1/2 (/ (- (* -3 (log (/ -1 re))) (* -1 (log (/ -1 re)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2)))))
(* -1/2 (/ (- (log (* -1 (pow re 3))) (log (neg re))) (log 1/10)))
(+ (* -1/2 (/ (- (log (* -1 (pow re 3))) (log (neg re))) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1/2 (/ (- (log (* -1 (pow re 3))) (log (neg re))) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1/2 (/ (- (log (* -1 (pow re 3))) (log (neg re))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(* -1/2 (/ (- (* -3 (log (/ 1 im))) (* -1 (log (/ 1 im)))) (log 1/10)))
(+ (* -1/2 (/ (- (* -3 (log (/ 1 im))) (* -1 (log (/ 1 im)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2))))
(+ (* -1/2 (/ (- (* -3 (log (/ 1 im))) (* -1 (log (/ 1 im)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* -2 (pow re 3)) (* 6 (pow re 3)))) (log 1/10))) (* -1/3 (/ (pow re 3) (log 1/10)))) (pow im 3))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2)))))
(+ (* -1/2 (/ (- (* -3 (log (/ 1 im))) (* -1 (log (/ 1 im)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/24 (/ (+ (* -24 (pow re 4)) (+ (* -12 (pow re 4)) (+ (* -6 (pow re 4)) (* 24 (pow re 4))))) (log 1/10))) (* -1/4 (/ (pow re 4) (log 1/10)))) (pow im 4))) (+ (* -1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* -2 (pow re 3)) (* 6 (pow re 3)))) (log 1/10))) (* -1/3 (/ (pow re 3) (log 1/10)))) (pow im 3))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2))))))
(* -1/2 (/ (- (* -3 (log (/ -1 im))) (* -1 (log (/ -1 im)))) (log 1/10)))
(+ (* -1/2 (/ (- (* -3 (log (/ -1 im))) (* -1 (log (/ -1 im)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2))))
(+ (* -1/2 (/ (- (* -3 (log (/ -1 im))) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2))) (* 1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* 2 (pow re 3)) (* 6 (pow re 3)))) (log 1/10))) (* 1/3 (/ (pow re 3) (log 1/10)))) (pow im 3)))))
(+ (* -1 (/ (+ (* -1/2 (- (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* 2 (pow re 3)) (* 6 (pow re 3)))) (log 1/10))) (* 1/3 (/ (pow re 3) (log 1/10))))) (* 1/2 (/ (- (* 1/24 (/ (+ (* -24 (pow re 4)) (+ (* -12 (pow re 4)) (+ (* -6 (pow re 4)) (* 24 (pow re 4))))) (log 1/10))) (* -1/4 (/ (pow re 4) (log 1/10)))) im))) (pow im 3))) (+ (* -1/2 (/ (- (* -3 (log (/ -1 im))) (* -1 (log (/ -1 im)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2)))))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(* 1/2 (/ re im))
(log (pow im 3))
(+ (log (pow im 3)) (* -1 (/ re im)))
(+ (log (pow im 3)) (* re (- (* 1/2 (/ re (pow im 2))) (/ 1 im))))
(+ (log (pow im 3)) (* re (- (* re (+ (* -1/3 (/ re (pow im 3))) (* 1/2 (/ 1 (pow im 2))))) (/ 1 im))))
(+ (log -1) (* -3 (log (/ 1 re))))
(+ (log -1) (+ (* -3 (log (/ 1 re))) (* -1 (/ im re))))
(+ (log -1) (+ (* -3 (log (/ 1 re))) (+ (* -1 (/ im re)) (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (pow re 2))))))
(+ (log -1) (+ (* -3 (log (/ 1 re))) (+ (* -1 (/ im re)) (+ (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* -2 (pow im 3)) (* 6 (pow im 3)))) (pow re 3))) (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (pow re 2)))))))
(* -3 (log (/ -1 re)))
(+ (* -3 (log (/ -1 re))) (* -1 (/ im re)))
(+ (* -3 (log (/ -1 re))) (* -1 (/ (+ im (* -1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) re))) re)))
(+ (* -3 (log (/ -1 re))) (* -1 (/ (+ im (* -1 (/ (+ (* -1/6 (/ (+ (* -6 (pow im 3)) (+ (* 2 (pow im 3)) (* 6 (pow im 3)))) re)) (* 1/2 (+ (* -1 (pow im 2)) (* 2 (pow im 2))))) re))) re)))
(log (* -1 (pow re 3)))
(+ (log (* -1 (pow re 3))) (* -1 (/ im re)))
(+ (log (* -1 (pow re 3))) (* im (- (* 1/2 (/ im (pow re 2))) (/ 1 re))))
(+ (log (* -1 (pow re 3))) (* im (- (* im (+ (* -1/3 (/ im (pow re 3))) (* 1/2 (/ 1 (pow re 2))))) (/ 1 re))))
(* -3 (log (/ 1 im)))
(+ (* -3 (log (/ 1 im))) (* -1 (/ re im)))
(+ (* -3 (log (/ 1 im))) (+ (* -1 (/ re im)) (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (pow im 2)))))
(+ (* -3 (log (/ 1 im))) (+ (* -1 (/ re im)) (+ (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* -2 (pow re 3)) (* 6 (pow re 3)))) (pow im 3))) (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (pow im 2))))))
(+ (log -1) (* -3 (log (/ -1 im))))
(+ (log -1) (+ (* -3 (log (/ -1 im))) (* -1 (/ re im))))
(+ (log -1) (+ (* -3 (log (/ -1 im))) (* -1 (/ (+ re (* -1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) im))) im))))
(+ (log -1) (+ (* -3 (log (/ -1 im))) (* -1 (/ (+ re (* -1 (/ (+ (* -1/6 (/ (+ (* -6 (pow re 3)) (+ (* 2 (pow re 3)) (* 6 (pow re 3)))) im)) (* 1/2 (+ (* -1 (pow re 2)) (* 2 (pow re 2))))) im))) im))))

Outputs
(* -1 (/ (log im) (log 1/10)))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (.f64 im (.f64 im (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/8 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (.f64 re re) (fma.f64 re (.f64 re (/.f64 #s(literal 1/8 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 im im) (.f64 im im))))) (/.f64 #s(literal -1/2 binary64) (.f64 im (.f64 im (log.f64 #s(literal 1/10 binary64)))))) (neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/24 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/8 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal -1/24 binary64) (/.f64 (.f64 re re) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 #s(literal 1/8 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 im im) (.f64 im im))))) (/.f64 #s(literal -1/2 binary64) (.f64 im (.f64 im (log.f64 #s(literal 1/10 binary64)))))) (neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10)))
(/.f64 (fma.f64 #s(literal 2 binary64) (log.f64 re) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))))
(-.f64 (/.f64 (.f64 (.f64 im im) #s(literal -2 binary64)) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re))) (/.f64 (fma.f64 #s(literal 2 binary64) (log.f64 re) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (log.f64 #s(literal 1/10 binary64))))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10))))))
(-.f64 (fma.f64 #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re))) (/.f64 (.f64 #s(literal 2 binary64) (.f64 (.f64 im im) (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 re re) (*.f64 re re))))) (/.f64 (fma.f64 #s(literal 2 binary64) (log.f64 re) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (log.f64 #s(literal 1/10 binary64))))
(+ (* -8/3 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10)))))))
(fma.f64 #s(literal -8/3 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (-.f64 (fma.f64 #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re))) (/.f64 (.f64 #s(literal 2 binary64) (.f64 (.f64 im im) (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 re re) (.f64 re re))))) (/.f64 (fma.f64 #s(literal 2 binary64) (log.f64 re) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (log.f64 #s(literal 1/10 binary64)))))
(* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10)))
(/.f64 (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (neg.f64 re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))))
(fma.f64 #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (/.f64 (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (neg.f64 re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10))))))
(fma.f64 #s(literal 2 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 re re) (.f64 re re)))) (fma.f64 #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re))) (/.f64 (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (neg.f64 re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))))
(+ (* -8/3 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1 (/ (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))) (log 1/10))) (* 2 (/ (pow im 4) (* (pow re 4) (log 1/10)))))))
(fma.f64 #s(literal -8/3 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 re re) (.f64 re re)))) (fma.f64 #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) (/.f64 (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (neg.f64 re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))))))
(* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10)))
(/.f64 (-.f64 (log.f64 im) (log.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))))) (log.f64 #s(literal 1/10 binary64)))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))))
(fma.f64 #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re))) (/.f64 (-.f64 (log.f64 im) (log.f64 (.f64 re (*.f64 re #s(literal 1/2 binary64))))) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))) (* (pow im 2) (- (* 2 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 im (.f64 im (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal -2 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re))))) (/.f64 (-.f64 (log.f64 im) (log.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))))) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (+ (log (* 1/2 (pow re 2))) (* -1 (log im))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -8/3 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 2 (/ 1 (* (pow re 4) (log 1/10)))))) (* 2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 #s(literal -8/3 binary64) (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 #s(literal 2 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 re re) (.f64 re re))))) (/.f64 #s(literal -2 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re)))) (/.f64 (-.f64 (log.f64 im) (log.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))))) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (.f64 im (.f64 im (log.f64 #s(literal 1/10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(-.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 im (.f64 im (log.f64 #s(literal 1/10 binary64))))) (/.f64 (.f64 #s(literal 1/8 binary64) (.f64 (.f64 re re) (.f64 re re))) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 im im) (*.f64 im im))))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/24 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(-.f64 (fma.f64 #s(literal -1/24 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 im (.f64 im (log.f64 #s(literal 1/10 binary64))))) (/.f64 (.f64 #s(literal 1/8 binary64) (.f64 (.f64 re re) (.f64 re re))) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 im im) (.f64 im im)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 im (*.f64 im (log.f64 #s(literal 1/10 binary64))))) (/.f64 (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10))))))
(fma.f64 #s(literal 1/8 binary64) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 im im) (.f64 im im)))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 im (.f64 im (log.f64 #s(literal 1/10 binary64))))) (/.f64 (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/24 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (* 1/8 (/ (pow re 4) (* (pow im 4) (log 1/10)))))))
(+.f64 (/.f64 (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64))) (fma.f64 #s(literal -1/24 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 im (.f64 im (log.f64 #s(literal 1/10 binary64))))) (/.f64 (.f64 #s(literal 1/8 binary64) (.f64 (.f64 re re) (.f64 re re))) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 im im) (.f64 im im)))))))
(* -1 (log im))
(neg.f64 (log.f64 im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (log im))
(-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (*.f64 im im)) (log.f64 im))
(- (* (pow re 2) (- (* 1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im))
(fma.f64 (.f64 re re) (fma.f64 re (.f64 re (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 im im) (.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (.f64 im im))) (neg.f64 (log.f64 im)))
(- (* (pow re 2) (- (* (pow re 2) (+ (* -1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))) (log im))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 #s(literal -1/24 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 im im) (.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (*.f64 im im))) (neg.f64 (log.f64 im)))
(* -1 (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))))
(-.f64 (*.f64 #s(literal -2 binary64) (log.f64 re)) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))
(- (* -2 (/ (pow im 2) (pow re 2))) (+ (log (/ 1/2 im)) (* -2 (log (/ 1 re)))))
(-.f64 (/.f64 (.f64 (.f64 im im) #s(literal -2 binary64)) (*.f64 re re)) (fma.f64 #s(literal 2 binary64) (log.f64 re) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(- (* 2 (/ (pow im 4) (pow re 4))) (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2))))))
(-.f64 (/.f64 (.f64 #s(literal 2 binary64) (.f64 (.f64 im im) (.f64 im im))) (.f64 (.f64 re re) (.f64 re re))) (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (*.f64 re re)) (fma.f64 #s(literal 2 binary64) (log.f64 re) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))))
(- (* -8/3 (/ (pow im 6) (pow re 6))) (+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2)))))))
(-.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal -8/3 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -2 binary64) (+.f64 (neg.f64 (log.f64 re)) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re)))) (fma.f64 im (.f64 im (/.f64 #s(literal 2 binary64) (*.f64 re re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))))
(* -1 (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))))
(-.f64 (*.f64 #s(literal 2 binary64) (neg.f64 (log.f64 (neg.f64 re)))) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))
(- (* -2 (/ (pow im 2) (pow re 2))) (+ (log (/ 1/2 im)) (* -2 (log (/ -1 re)))))
(-.f64 (/.f64 (.f64 (.f64 im im) #s(literal -2 binary64)) (*.f64 re re)) (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (neg.f64 re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(- (* 2 (/ (pow im 4) (pow re 4))) (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2))))))
(-.f64 (/.f64 (.f64 #s(literal 2 binary64) (.f64 (.f64 im im) (.f64 im im))) (.f64 (.f64 re re) (.f64 re re))) (fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (*.f64 re re)) (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (neg.f64 re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))))
(- (* -8/3 (/ (pow im 6) (pow re 6))) (+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2)))))))
(-.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal -8/3 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 #s(literal -2 binary64) (+.f64 (neg.f64 (log.f64 (neg.f64 re))) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re)))) (fma.f64 im (.f64 im (/.f64 #s(literal 2 binary64) (*.f64 re re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))))
(* -1 (+ (log (* 1/2 (pow re 2))) (* -1 (log im))))
(-.f64 (log.f64 im) (log.f64 (.f64 re (.f64 re #s(literal 1/2 binary64)))))
(- (* -2 (/ (pow im 2) (pow re 2))) (+ (log (* 1/2 (pow re 2))) (* -1 (log im))))
(fma.f64 (.f64 im im) (/.f64 #s(literal -2 binary64) (.f64 re re)) (-.f64 (log.f64 im) (log.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))))))
(- (* (pow im 2) (- (* 2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2))))) (+ (log (* 1/2 (pow re 2))) (* -1 (log im))))
(fma.f64 im (.f64 im (fma.f64 im (.f64 im (/.f64 #s(literal 2 binary64) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal -2 binary64) (.f64 re re)))) (-.f64 (log.f64 im) (log.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))))))
(- (* (pow im 2) (- (* (pow im 2) (+ (* -8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2))))) (+ (log (* 1/2 (pow re 2))) (* -1 (log im))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 #s(literal -8/3 binary64) (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal 2 binary64) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal -2 binary64) (.f64 re re))) (-.f64 (log.f64 im) (log.f64 (.f64 re (*.f64 re #s(literal 1/2 binary64))))))
(log (/ 1 im))
(neg.f64 (log.f64 im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))
(-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (*.f64 im im)) (log.f64 im))
(- (* 1/8 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(-.f64 (/.f64 (.f64 #s(literal 1/8 binary64) (.f64 (.f64 re re) (.f64 re re))) (.f64 (.f64 im im) (.f64 im im))) (fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 im im)) (log.f64 im)))
(- (* -1/24 (/ (pow re 6) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (/.f64 (.f64 #s(literal -1/24 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))) (fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im im)) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (*.f64 im im))) #s(literal -1/8 binary64) (log.f64 im))))
(* -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64)))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (+ (log -1) (* -1 (log (/ -1 im)))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))))
(- (* 1/8 (/ (pow re 4) (pow im 4))) (+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 #s(literal 1/8 binary64) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)) (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64)))))
(- (* -1/24 (/ (pow re 6) (pow im 6))) (+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 #s(literal -1/24 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (-.f64 (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))) (fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im im)) (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal -1/8 binary64)) (.f64 (.f64 im im) (*.f64 im im))))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im im)) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/24 (/ (pow re 2) (pow im 6))) (* 1/8 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 re re) (fma.f64 (.f64 re re) (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/24 binary64) (/.f64 #s(literal -1/8 binary64) (.f64 (.f64 im im) (.f64 im im)))) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))) (log.f64 im))
(+ (log (/ 1/2 im)) (* -2 (log (/ 1 re))))
(fma.f64 #s(literal 2 binary64) (log.f64 re) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (fma.f64 #s(literal 2 binary64) (log.f64 re) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (neg.f64 (log.f64 re)) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re)))) (fma.f64 im (.f64 im (/.f64 #s(literal 2 binary64) (.f64 re re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ 1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+.f64 (fma.f64 #s(literal -2 binary64) (+.f64 (neg.f64 (log.f64 re)) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re)))) (fma.f64 im (.f64 im (/.f64 #s(literal 2 binary64) (.f64 re re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 8/3 binary64)) (pow.f64 re #s(literal 6 binary64))))
(+ (log (/ 1/2 im)) (* -2 (log (/ -1 re))))
(fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (neg.f64 re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im)))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re)) (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (neg.f64 re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (* 2 (/ (pow im 2) (pow re 2))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (neg.f64 (log.f64 (neg.f64 re))) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re)))) (fma.f64 im (.f64 im (/.f64 #s(literal 2 binary64) (.f64 re re))) (log.f64 (/.f64 #s(literal 1/2 binary64) im))))
(+ (log (/ 1/2 im)) (+ (* -2 (log (/ -1 re))) (+ (* -2 (/ (pow im 4) (pow re 4))) (+ (* 2 (/ (pow im 2) (pow re 2))) (* 8/3 (/ (pow im 6) (pow re 6)))))))
(+.f64 (log.f64 (/.f64 #s(literal 1/2 binary64) im)) (fma.f64 #s(literal -2 binary64) (+.f64 (neg.f64 (log.f64 (neg.f64 re))) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re)))) (fma.f64 im (.f64 im (/.f64 #s(literal 2 binary64) (.f64 re re))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 8/3 binary64)) (pow.f64 re #s(literal 6 binary64))))))
(+ (log (* 1/2 (pow re 2))) (* -1 (log im)))
(-.f64 (log.f64 (.f64 re (.f64 re #s(literal 1/2 binary64)))) (log.f64 im))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* 2 (/ (pow im 2) (pow re 2)))))
(fma.f64 im (.f64 im (/.f64 #s(literal 2 binary64) (.f64 re re))) (-.f64 (log.f64 (.f64 re (.f64 re #s(literal 1/2 binary64)))) (log.f64 im)))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* -2 (/ (pow im 2) (pow re 4))) (* 2 (/ 1 (pow re 2)))))))
(fma.f64 (.f64 im im) (fma.f64 #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 (.f64 re re) (.f64 re re))) (/.f64 #s(literal 2 binary64) (.f64 re re))) (-.f64 (log.f64 (.f64 re (.f64 re #s(literal 1/2 binary64)))) (log.f64 im)))
(+ (log (* 1/2 (pow re 2))) (+ (* -1 (log im)) (* (pow im 2) (+ (* (pow im 2) (- (* 8/3 (/ (pow im 2) (pow re 6))) (* 2 (/ 1 (pow re 4))))) (* 2 (/ 1 (pow re 2)))))))
(fma.f64 (.f64 im im) (fma.f64 (.f64 im im) (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 8/3 binary64) (/.f64 #s(literal -2 binary64) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal 2 binary64) (.f64 re re))) (-.f64 (log.f64 (.f64 re (*.f64 re #s(literal 1/2 binary64)))) (log.f64 im)))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im im)) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im im)) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/8 binary64) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im im)) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/8 binary64) (log.f64 im))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/24 binary64)) (pow.f64 im #s(literal 6 binary64))))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im im)) (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (-.f64 (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal -1/8 binary64)) (.f64 (.f64 im im) (.f64 im im))) (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (*.f64 im im)) (log.f64 #s(literal -1 binary64))))
(+ (log -1) (+ (* -1 (log (/ -1 im))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/24 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/8 binary64) (fma.f64 re (/.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 im im)) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/24 binary64)) (pow.f64 im #s(literal 6 binary64))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)
(* 1/2 (/ (pow re 2) im))
(/.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* 1/2 (/ (pow re 2) im))
(/.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))) im)
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* (pow re 2) (+ (* 1/2 (/ 1 im)) (/ im (pow re 2))))
(.f64 (.f64 re re) (+.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 im (*.f64 re re))))
(* 1/2 (/ (pow re 2) im))
(/.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (.f64 re (.f64 re #s(literal 1/2 binary64)))) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (.f64 re (.f64 re #s(literal 1/2 binary64)))) im)
(/ (+ (* 1/2 (pow re 2)) (pow im 2)) im)
(/.f64 (fma.f64 im im (.f64 re (.f64 re #s(literal 1/2 binary64)))) im)
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (.f64 re re) (.f64 im im)) (*.f64 im #s(literal 1/2 binary64)) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (.f64 re re) (.f64 im im)) (*.f64 im #s(literal 1/2 binary64)) im)
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (.f64 re re) (.f64 im im)) (*.f64 im #s(literal 1/2 binary64)) im)
im
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(.f64 (fma.f64 (.f64 re re) (/.f64 #s(literal -1/2 binary64) (*.f64 im im)) #s(literal -1 binary64)) (neg.f64 im))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(.f64 (fma.f64 (.f64 re re) (/.f64 #s(literal -1/2 binary64) (*.f64 im im)) #s(literal -1 binary64)) (neg.f64 im))
(* -1 (* im (- (* -1/2 (/ (pow re 2) (pow im 2))) 1)))
(.f64 (fma.f64 (.f64 re re) (/.f64 #s(literal -1/2 binary64) (*.f64 im im)) #s(literal -1 binary64)) (neg.f64 im))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))) (log.f64 #s(literal 10 binary64)))
(/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))) (log.f64 #s(literal 10 binary64)))
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im))))
(* -1 (/ (log im) (log 1/10)))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (log 1/10) (log im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(* -1 (/ (log 1/10) (log im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(* -1 (/ (log 1/10) (log im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(* -1 (/ (log 1/10) (log im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(/ (log 1/10) (log (/ 1 im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(/ (log 1/10) (log (/ 1 im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(/ (log 1/10) (log (/ 1 im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(/ (log 1/10) (log (/ 1 im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(* -1 (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))))
(* -1 (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))))
(* -1 (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))))
(* -1 (/ (log 1/10) (+ (log -1) (* -1 (log (/ -1 im))))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))))
(/ -1 (log im))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ -1 (log im))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ -1 (log im))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ -1 (log im))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ 1 (log (/ 1 im)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ 1 (log (/ 1 im)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ 1 (log (/ 1 im)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ 1 (log (/ 1 im)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))))
(/ -1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal -1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))))
(* -1 (/ (log im) (log 1/10)))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (log 1/10)))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(/ (log (/ 1 im)) (log 1/10))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))
(/.f64 (-.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))))
(/ 1 (+ (log -1) (* -1 (log (/ -1 im)))))
(/.f64 #s(literal 1 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 (neg.f64 im)))))
(pow im 3)
(.f64 im (.f64 im im))
(+ (* -1 (* (pow im 2) re)) (pow im 3))
(.f64 (.f64 im im) (-.f64 im re))
(+ (* re (+ (* -1 (pow im 2)) (* im re))) (pow im 3))
(.f64 im (fma.f64 im im (.f64 re (-.f64 re im))))
(+ (* re (+ (* -1 (pow im 2)) (* re (+ im (* -1 re))))) (pow im 3))
(fma.f64 im (.f64 im (-.f64 im re)) (.f64 re (*.f64 re (-.f64 im re))))
(* -1 (pow re 3))
(neg.f64 (.f64 re (.f64 re re)))
(* (pow re 3) (- (/ im re) 1))
(.f64 (.f64 re (*.f64 re re)) (+.f64 #s(literal -1 binary64) (/.f64 im re)))
(* (pow re 3) (- (+ (* -1 (/ (pow im 2) (pow re 2))) (/ im re)) 1))
(.f64 (.f64 re (.f64 re re)) (+.f64 #s(literal -1 binary64) (/.f64 (-.f64 im (/.f64 (.f64 im im) re)) re)))
(* (pow re 3) (- (+ (* -1 (/ (pow im 2) (pow re 2))) (+ (/ im re) (/ (pow im 3) (pow re 3)))) 1))
(.f64 (.f64 re (.f64 re re)) (+.f64 (/.f64 (-.f64 im (/.f64 (.f64 im im) re)) re) (fma.f64 (.f64 im im) (/.f64 im (.f64 re (*.f64 re re))) #s(literal -1 binary64))))
(* -1 (pow re 3))
(neg.f64 (.f64 re (.f64 re re)))
(* -1 (* (pow re 3) (+ 1 (* -1 (/ im re)))))
(.f64 (.f64 re (*.f64 re re)) (+.f64 #s(literal -1 binary64) (/.f64 im re)))
(* -1 (* (pow re 3) (+ 1 (* -1 (/ (+ im (* -1 (/ (pow im 2) re))) re)))))
(.f64 (.f64 re (.f64 re re)) (+.f64 #s(literal -1 binary64) (/.f64 (-.f64 im (/.f64 (.f64 im im) re)) re)))
(* -1 (* (pow re 3) (+ 1 (* -1 (/ (+ im (* -1 (/ (+ (* -1 (/ (pow im 3) re)) (pow im 2)) re))) re)))))
(.f64 (neg.f64 (.f64 re (.f64 re re))) (-.f64 #s(literal 1 binary64) (/.f64 (-.f64 im (/.f64 (fma.f64 im im (.f64 im (*.f64 im (/.f64 im (neg.f64 re))))) re)) re)))
(* -1 (pow re 3))
(neg.f64 (.f64 re (.f64 re re)))
(+ (* -1 (pow re 3)) (* im (pow re 2)))
(.f64 re (.f64 re (-.f64 im re)))
(+ (* -1 (pow re 3)) (* im (+ (* -1 (* im re)) (pow re 2))))
(.f64 re (-.f64 (.f64 re (-.f64 im re)) (*.f64 im im)))
(+ (* -1 (pow re 3)) (* im (+ (* im (+ im (* -1 re))) (pow re 2))))
(fma.f64 im (.f64 im (-.f64 im re)) (.f64 re (*.f64 re (-.f64 im re))))
(pow im 3)
(.f64 im (.f64 im im))
(* (pow im 3) (+ 1 (* -1 (/ re im))))
(.f64 (.f64 im im) (*.f64 im (-.f64 #s(literal 1 binary64) (/.f64 re im))))
(* (pow im 3) (+ 1 (+ (* -1 (/ re im)) (/ (pow re 2) (pow im 2)))))
(.f64 (.f64 im (*.f64 im im)) (+.f64 #s(literal 1 binary64) (/.f64 (fma.f64 re (/.f64 re im) (neg.f64 re)) im)))
(* (pow im 3) (+ 1 (+ (* -1 (/ re im)) (+ (* -1 (/ (pow re 3) (pow im 3))) (/ (pow re 2) (pow im 2))))))
(.f64 im (.f64 (.f64 im im) (+.f64 #s(literal 1 binary64) (fma.f64 (neg.f64 re) (/.f64 (.f64 re re) (.f64 im (.f64 im im))) (/.f64 (fma.f64 re (/.f64 re im) (neg.f64 re)) im)))))
(pow im 3)
(.f64 im (.f64 im im))
(* -1 (* (pow im 3) (- (/ re im) 1)))
(.f64 (neg.f64 (.f64 im im)) (*.f64 im (+.f64 #s(literal -1 binary64) (/.f64 re im))))
(* -1 (* (pow im 3) (- (* -1 (/ (+ (* -1 re) (/ (pow re 2) im)) im)) 1)))
(.f64 (-.f64 #s(literal -1 binary64) (/.f64 (fma.f64 re (/.f64 re im) (neg.f64 re)) im)) (neg.f64 (.f64 im (*.f64 im im))))
(* -1 (* (pow im 3) (- (* -1 (/ (+ (* -1 re) (* -1 (/ (+ (* -1 (pow re 2)) (/ (pow re 3) im)) im))) im)) 1)))
(.f64 (+.f64 #s(literal -1 binary64) (/.f64 (+.f64 re (/.f64 (fma.f64 re (/.f64 (.f64 re re) im) (.f64 re (neg.f64 re))) im)) im)) (neg.f64 (.f64 im (*.f64 im im))))
(* -1/2 (/ (- (log (pow im 3)) (log im)) (log 1/10)))
(/.f64 (.f64 #s(literal -1/2 binary64) (-.f64 (log.f64 (.f64 im (*.f64 im im))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (- (log (pow im 3)) (log im)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(.f64 #s(literal -1/2 binary64) (fma.f64 re (/.f64 re (.f64 im (.f64 im (log.f64 #s(literal 1/10 binary64))))) (/.f64 (-.f64 (log.f64 (.f64 im (*.f64 im im))) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (- (log (pow im 3)) (log im)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (-.f64 (log.f64 (.f64 im (.f64 im im))) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (.f64 (.f64 re re) (fma.f64 (.f64 re re) (/.f64 #s(literal 1/4 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 im im) (.f64 im im)))) (/.f64 #s(literal -1/2 binary64) (.f64 im (*.f64 im (log.f64 #s(literal 1/10 binary64))))))))
(+ (* -1/2 (/ (- (log (pow im 3)) (log im)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (-.f64 (log.f64 (.f64 im (.f64 im im))) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (.f64 (.f64 re re) (fma.f64 re (.f64 re (fma.f64 (/.f64 (.f64 re re) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 im im) (.f64 im im)))))) (/.f64 #s(literal -1/2 binary64) (.f64 im (*.f64 im (log.f64 #s(literal 1/10 binary64))))))))
(* -1/2 (/ (- (* -3 (log (/ 1 re))) (* -1 (log (/ 1 re)))) (log 1/10)))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (- (* -3 (log (/ 1 re))) (* -1 (log (/ 1 re)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 im (/.f64 im (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (*.f64 re re)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (- (* -3 (log (/ 1 re))) (* -1 (log (/ 1 re)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* -2 (pow im 3)) (* 6 (pow im 3)))) (log 1/10))) (* -1/3 (/ (pow im 3) (log 1/10)))) (pow re 3))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2)))))
(fma.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 im (/.f64 im (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re)) (/.f64 (fma.f64 (/.f64 (.f64 im (.f64 im im)) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/3 binary64) (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 im (.f64 (.f64 im im) #s(literal -2 binary64)))) (log.f64 #s(literal 1/10 binary64)))) (.f64 re (*.f64 re re)))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (- (* -3 (log (/ 1 re))) (* -1 (log (/ 1 re)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/24 (/ (+ (* -24 (pow im 4)) (+ (* -12 (pow im 4)) (+ (* -6 (pow im 4)) (* 24 (pow im 4))))) (log 1/10))) (* -1/4 (/ (pow im 4) (log 1/10)))) (pow re 4))) (+ (* -1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* -2 (pow im 3)) (* 6 (pow im 3)))) (log 1/10))) (* -1/3 (/ (pow im 3) (log 1/10)))) (pow re 3))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2))))))
(fma.f64 #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 im (/.f64 im (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re)) (/.f64 (fma.f64 (/.f64 (.f64 im (.f64 im im)) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/3 binary64) (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 im (.f64 (.f64 im im) #s(literal -2 binary64)))) (log.f64 #s(literal 1/10 binary64)))) (.f64 re (.f64 re re)))) (/.f64 (fma.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 6 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal -24 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/4 binary64)) (log.f64 #s(literal 1/10 binary64)))) (.f64 (.f64 re re) (*.f64 re re)))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(* -1/2 (/ (- (* -3 (log (/ -1 re))) (* -1 (log (/ -1 re)))) (log 1/10)))
(/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (- (* -3 (log (/ -1 re))) (* -1 (log (/ -1 re)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 im (/.f64 im (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (*.f64 re re)) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (- (* -3 (log (/ -1 re))) (* -1 (log (/ -1 re)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2))) (* 1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* 2 (pow im 3)) (* 6 (pow im 3)))) (log 1/10))) (* 1/3 (/ (pow im 3) (log 1/10)))) (pow re 3)))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 im (/.f64 im (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re)) (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 im (.f64 #s(literal 2 binary64) (.f64 im im))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/3 binary64)) (log.f64 #s(literal 1/10 binary64)))) (.f64 re (*.f64 re re))) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1 (/ (+ (* -1/2 (- (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* 2 (pow im 3)) (* 6 (pow im 3)))) (log 1/10))) (* 1/3 (/ (pow im 3) (log 1/10))))) (* 1/2 (/ (- (* 1/24 (/ (+ (* -24 (pow im 4)) (+ (* -12 (pow im 4)) (+ (* -6 (pow im 4)) (* 24 (pow im 4))))) (log 1/10))) (* -1/4 (/ (pow im 4) (log 1/10)))) re))) (pow re 3))) (+ (* -1/2 (/ (- (* -3 (log (/ -1 re))) (* -1 (log (/ -1 re)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (log 1/10))) (* -1/2 (/ (pow im 2) (log 1/10)))) (pow re 2)))))
(-.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 im (/.f64 im (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re)) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (fma.f64 #s(literal -1/2 binary64) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 im (.f64 #s(literal 2 binary64) (.f64 im im))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (.f64 im (.f64 im im)) #s(literal -1/3 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 6 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal -24 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (.f64 (.f64 im im) (.f64 im im)) #s(literal 1/4 binary64)) (log.f64 #s(literal 1/10 binary64))))) re)) (.f64 re (*.f64 re re))))
(* -1/2 (/ (- (log (* -1 (pow re 3))) (log (neg re))) (log 1/10)))
(/.f64 (.f64 #s(literal -1/2 binary64) (-.f64 (log.f64 (neg.f64 (.f64 re (*.f64 re re)))) (log.f64 (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (- (log (* -1 (pow re 3))) (log (neg re))) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(.f64 #s(literal -1/2 binary64) (fma.f64 im (/.f64 im (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re))) (/.f64 (-.f64 (log.f64 (neg.f64 (.f64 re (*.f64 re re)))) (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (- (log (* -1 (pow re 3))) (log (neg re))) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 im (.f64 im (fma.f64 (.f64 im im) (/.f64 #s(literal 1/4 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 re re) (.f64 re re)))) (/.f64 #s(literal -1/2 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re))))) (/.f64 (.f64 #s(literal -1/2 binary64) (-.f64 (log.f64 (neg.f64 (.f64 re (*.f64 re re)))) (log.f64 (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (- (log (* -1 (pow re 3))) (log (neg re))) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (.f64 im im) (fma.f64 im (.f64 im (fma.f64 (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (.f64 re re) (.f64 re re)))))) (/.f64 #s(literal -1/2 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re)))) (/.f64 (.f64 #s(literal -1/2 binary64) (-.f64 (log.f64 (neg.f64 (.f64 re (*.f64 re re)))) (log.f64 (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64))))
(* -1/2 (/ (- (* -3 (log (/ 1 im))) (* -1 (log (/ 1 im)))) (log 1/10)))
(/.f64 (.f64 #s(literal -1/2 binary64) (.f64 (log.f64 im) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (- (* -3 (log (/ 1 im))) (* -1 (log (/ 1 im)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2))))
(.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 (.f64 (log.f64 im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 re (/.f64 re (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (*.f64 im im))))
(+ (* -1/2 (/ (- (* -3 (log (/ 1 im))) (* -1 (log (/ 1 im)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* -2 (pow re 3)) (* 6 (pow re 3)))) (log 1/10))) (* -1/3 (/ (pow re 3) (log 1/10)))) (pow im 3))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2)))))
(.f64 #s(literal -1/2 binary64) (+.f64 (/.f64 (.f64 (log.f64 im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) (+.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 re (/.f64 re (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im)) (/.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re (.f64 (.f64 re re) #s(literal -2 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (.f64 re (.f64 re re)) #s(literal 1/3 binary64)) (log.f64 #s(literal 1/10 binary64)))) (.f64 im (*.f64 im im))))))
(+ (* -1/2 (/ (- (* -3 (log (/ 1 im))) (* -1 (log (/ 1 im)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/24 (/ (+ (* -24 (pow re 4)) (+ (* -12 (pow re 4)) (+ (* -6 (pow re 4)) (* 24 (pow re 4))))) (log 1/10))) (* -1/4 (/ (pow re 4) (log 1/10)))) (pow im 4))) (+ (* -1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* -2 (pow re 3)) (* 6 (pow re 3)))) (log 1/10))) (* -1/3 (/ (pow re 3) (log 1/10)))) (pow im 3))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2))))))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (log.f64 im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) (.f64 #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 re (/.f64 re (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im)) (/.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re (.f64 (.f64 re re) #s(literal -2 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (.f64 re (.f64 re re)) #s(literal 1/3 binary64)) (log.f64 #s(literal 1/10 binary64)))) (.f64 im (.f64 im im)))) (/.f64 (fma.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal 6 binary64) (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal -24 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal 1/4 binary64)) (log.f64 #s(literal 1/10 binary64)))) (.f64 (.f64 im im) (*.f64 im im))))))
(* -1/2 (/ (- (* -3 (log (/ -1 im))) (* -1 (log (/ -1 im)))) (log 1/10)))
(.f64 #s(literal -1/2 binary64) (.f64 (neg.f64 (log.f64 (neg.f64 im))) (/.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (- (* -3 (log (/ -1 im))) (* -1 (log (/ -1 im)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2))))
(.f64 #s(literal -1/2 binary64) (fma.f64 (neg.f64 (log.f64 (neg.f64 im))) (/.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 re (/.f64 re (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im))))
(+ (* -1/2 (/ (- (* -3 (log (/ -1 im))) (* -1 (log (/ -1 im)))) (log 1/10))) (+ (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2))) (* 1/2 (/ (- (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* 2 (pow re 3)) (* 6 (pow re 3)))) (log 1/10))) (* 1/3 (/ (pow re 3) (log 1/10)))) (pow im 3)))))
(fma.f64 #s(literal -1/2 binary64) (fma.f64 (neg.f64 (log.f64 (neg.f64 im))) (/.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 re (/.f64 re (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im))) (.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re (.f64 #s(literal 2 binary64) (.f64 re re))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (.f64 #s(literal -1/3 binary64) (.f64 re re)) re) (log.f64 #s(literal 1/10 binary64)))) (.f64 im (.f64 im im)))))
(+ (* -1 (/ (+ (* -1/2 (- (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* 2 (pow re 3)) (* 6 (pow re 3)))) (log 1/10))) (* 1/3 (/ (pow re 3) (log 1/10))))) (* 1/2 (/ (- (* 1/24 (/ (+ (* -24 (pow re 4)) (+ (* -12 (pow re 4)) (+ (* -6 (pow re 4)) (* 24 (pow re 4))))) (log 1/10))) (* -1/4 (/ (pow re 4) (log 1/10)))) im))) (pow im 3))) (+ (* -1/2 (/ (- (* -3 (log (/ -1 im))) (* -1 (log (/ -1 im)))) (log 1/10))) (* -1/2 (/ (- (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (log 1/10))) (* -1/2 (/ (pow re 2) (log 1/10)))) (pow im 2)))))
(-.f64 (.f64 #s(literal -1/2 binary64) (fma.f64 (neg.f64 (log.f64 (neg.f64 im))) (/.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (fma.f64 re (/.f64 re (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im)))) (/.f64 (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 #s(literal 1/24 binary64) (/.f64 (fma.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal 6 binary64) (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal -24 binary64))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (.f64 (.f64 re re) (.f64 re re)) #s(literal 1/4 binary64)) (log.f64 #s(literal 1/10 binary64)))) im) (.f64 #s(literal -1/2 binary64) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re (.f64 #s(literal 2 binary64) (.f64 re re))) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (.f64 #s(literal -1/3 binary64) (.f64 re re)) re) (log.f64 #s(literal 1/10 binary64)))))) (.f64 im (.f64 im im))))
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(* 1/2 (/ re im))
(/.f64 (*.f64 re #s(literal 1/2 binary64)) im)
(log (pow im 3))
(log.f64 (.f64 im (.f64 im im)))
(+ (log (pow im 3)) (* -1 (/ re im)))
(-.f64 (log.f64 (.f64 im (.f64 im im))) (/.f64 re im))
(+ (log (pow im 3)) (* re (- (* 1/2 (/ re (pow im 2))) (/ 1 im))))
(fma.f64 re (fma.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 #s(literal -1 binary64) im)) (log.f64 (.f64 im (*.f64 im im))))
(+ (log (pow im 3)) (* re (- (* re (+ (* -1/3 (/ re (pow im 3))) (* 1/2 (/ 1 (pow im 2))))) (/ 1 im))))
(fma.f64 re (fma.f64 re (fma.f64 #s(literal -1/3 binary64) (/.f64 re (.f64 im (.f64 im im))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (/.f64 #s(literal -1 binary64) im)) (log.f64 (.f64 im (*.f64 im im))))
(+ (log -1) (* -3 (log (/ 1 re))))
(fma.f64 #s(literal 3 binary64) (log.f64 re) (log.f64 #s(literal -1 binary64)))
(+ (log -1) (+ (* -3 (log (/ 1 re))) (* -1 (/ im re))))
(-.f64 (fma.f64 #s(literal 3 binary64) (log.f64 re) (log.f64 #s(literal -1 binary64))) (/.f64 im re))
(+ (log -1) (+ (* -3 (log (/ 1 re))) (+ (* -1 (/ im re)) (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (pow re 2))))))
(+.f64 (fma.f64 #s(literal 3 binary64) (log.f64 re) (log.f64 #s(literal -1 binary64))) (-.f64 (/.f64 (.f64 (.f64 im im) #s(literal 1/2 binary64)) (*.f64 re re)) (/.f64 im re)))
(+ (log -1) (+ (* -3 (log (/ 1 re))) (+ (* -1 (/ im re)) (+ (* 1/6 (/ (+ (* -6 (pow im 3)) (+ (* -2 (pow im 3)) (* 6 (pow im 3)))) (pow re 3))) (* 1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) (pow re 2)))))))
(+.f64 (fma.f64 #s(literal 3 binary64) (log.f64 re) (log.f64 #s(literal -1 binary64))) (fma.f64 (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 im (.f64 (.f64 im im) #s(literal -2 binary64)))) (.f64 re (.f64 re re))) (/.f64 im re))))
(* -3 (log (/ -1 re)))
(*.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal -3 binary64))
(+ (* -3 (log (/ -1 re))) (* -1 (/ im re)))
(fma.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal -3 binary64) (/.f64 im (neg.f64 re)))
(+ (* -3 (log (/ -1 re))) (* -1 (/ (+ im (* -1/2 (/ (+ (* -1 (pow im 2)) (* 2 (pow im 2))) re))) re)))
(fma.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal -3 binary64) (neg.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 im im) re) im) re)))
(+ (* -3 (log (/ -1 re))) (* -1 (/ (+ im (* -1 (/ (+ (* -1/6 (/ (+ (* -6 (pow im 3)) (+ (* 2 (pow im 3)) (* 6 (pow im 3)))) re)) (* 1/2 (+ (* -1 (pow im 2)) (* 2 (pow im 2))))) re))) re)))
(-.f64 (.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal -3 binary64)) (/.f64 (-.f64 im (/.f64 (fma.f64 #s(literal -1/6 binary64) (/.f64 (.f64 im (.f64 #s(literal 2 binary64) (.f64 im im))) re) (.f64 (.f64 im im) #s(literal 1/2 binary64))) re)) re))
(log (* -1 (pow re 3)))
(log.f64 (neg.f64 (.f64 re (.f64 re re))))
(+ (log (* -1 (pow re 3))) (* -1 (/ im re)))
(-.f64 (log.f64 (neg.f64 (.f64 re (.f64 re re)))) (/.f64 im re))
(+ (log (* -1 (pow re 3))) (* im (- (* 1/2 (/ im (pow re 2))) (/ 1 re))))
(fma.f64 im (fma.f64 #s(literal 1/2 binary64) (/.f64 im (.f64 re re)) (/.f64 #s(literal -1 binary64) re)) (log.f64 (neg.f64 (.f64 re (*.f64 re re)))))
(+ (log (* -1 (pow re 3))) (* im (- (* im (+ (* -1/3 (/ im (pow re 3))) (* 1/2 (/ 1 (pow re 2))))) (/ 1 re))))
(fma.f64 im (fma.f64 im (fma.f64 #s(literal -1/3 binary64) (/.f64 im (.f64 re (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (/.f64 #s(literal -1 binary64) re)) (log.f64 (neg.f64 (.f64 re (*.f64 re re)))))
(* -3 (log (/ 1 im)))
(*.f64 (log.f64 im) #s(literal 3 binary64))
(+ (* -3 (log (/ 1 im))) (* -1 (/ re im)))
(-.f64 (*.f64 (log.f64 im) #s(literal 3 binary64)) (/.f64 re im))
(+ (* -3 (log (/ 1 im))) (+ (* -1 (/ re im)) (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (pow im 2)))))
(fma.f64 re (fma.f64 re (/.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 #s(literal -1 binary64) im)) (.f64 (log.f64 im) #s(literal 3 binary64)))
(+ (* -3 (log (/ 1 im))) (+ (* -1 (/ re im)) (+ (* 1/6 (/ (+ (* -6 (pow re 3)) (+ (* -2 (pow re 3)) (* 6 (pow re 3)))) (pow im 3))) (* 1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) (pow im 2))))))
(fma.f64 (log.f64 im) #s(literal 3 binary64) (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re (.f64 (.f64 re re) #s(literal -2 binary64))) (.f64 im (.f64 im im))) (.f64 re (fma.f64 re (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) (/.f64 #s(literal -1 binary64) im)))))
(+ (log -1) (* -3 (log (/ -1 im))))
(fma.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -3 binary64) (log.f64 #s(literal -1 binary64)))
(+ (log -1) (+ (* -3 (log (/ -1 im))) (* -1 (/ re im))))
(fma.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -3 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (/.f64 re im)))
(+ (log -1) (+ (* -3 (log (/ -1 im))) (* -1 (/ (+ re (* -1/2 (/ (+ (* -1 (pow re 2)) (* 2 (pow re 2))) im))) im))))
(fma.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -3 binary64) (-.f64 (log.f64 #s(literal -1 binary64)) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (*.f64 re re) im) re) im)))
(+ (log -1) (+ (* -3 (log (/ -1 im))) (* -1 (/ (+ re (* -1 (/ (+ (* -1/6 (/ (+ (* -6 (pow re 3)) (+ (* 2 (pow re 3)) (* 6 (pow re 3)))) im)) (* 1/2 (+ (* -1 (pow re 2)) (* 2 (pow re 2))))) im))) im))))
(-.f64 (fma.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -3 binary64) (log.f64 #s(literal -1 binary64))) (/.f64 (-.f64 re (/.f64 (fma.f64 re (.f64 re #s(literal 1/2 binary64)) (/.f64 (.f64 #s(literal -1/6 binary64) (.f64 re (.f64 #s(literal 2 binary64) (*.f64 re re)))) im)) im)) im))

eval125.0ms (1.3%)

Memory: 10.6MiB live, 319.5MiB allocated
Compiler: Compiled 23 639 to 2 888 computations (87.8% saved)

prune313.0ms (3.4%)

Memory

-34.3MiB live, 274.6MiB allocated

Pruning

19 alts after pruning (9 fresh and 10 done)

	Pruned	Kept	Total
New	1 017	4	1 021
Fresh	5	5	10
Picked	1	4	5
Done	0	6	6
Total	1 023	19	1 042

Accuracy

100.0%

Counts

1 042 → 19

Alt Table

Click to see full alt table

Status	Accuracy	Program
	35.6%	(pow.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) #s(literal 2 binary64))
	96.8%	(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (-.f64 (*.f64 (log.f64 im) #s(literal 3 binary64)) (log.f64 (-.f64 im re)))))
	37.8%	(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (-.f64 (log.f64 (.f64 im (.f64 im im))) (log.f64 (-.f64 im re)))))
✓	97.9%	(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
	54.2%	(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
✓	98.3%	(/.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) (log.f64 #s(literal 1/10 binary64)))
✓	97.8%	(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
✓	98.3%	(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	97.9%	(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
✓	97.9%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
	97.9%	(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
✓	97.8%	(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
	97.8%	(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
	98.4%	(*.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (log.f64 im))
✓	97.4%	(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
	97.8%	(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
	54.1%	(.f64 (.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))))

Compiler

Compiled 894 to 356 computations (60.2% saved)

regimes179.0ms (1.9%)

Memory

26.8MiB live, 184.8MiB allocated

Counts

43 → 1

Calls

Call 1

Inputs
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 (log.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (+.f64 re im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 (.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 (sqrt.f64 (/.f64 (-.f64 (.f64 (/.f64 (.f64 re (.f64 re (.f64 re re))) (+.f64 re im)) (-.f64 re im)) (.f64 (-.f64 re im) (/.f64 (.f64 im (.f64 im (.f64 im im))) (+.f64 re im)))) (*.f64 (-.f64 re im) (-.f64 re im))))) (log.f64 #s(literal 10 binary64)))
(pow.f64 (sqrt.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))) #s(literal 2 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (-.f64 (*.f64 (log.f64 im) #s(literal 3 binary64)) (log.f64 (-.f64 im re)))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (-.f64 (log.f64 (.f64 im (.f64 im im))) (log.f64 (-.f64 im re)))))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (-.f64 (log.f64 (/.f64 (.f64 (fma.f64 re re (.f64 im im)) (*.f64 (+.f64 re im) (-.f64 im re))) (+.f64 re im))) (log.f64 (-.f64 im re)))))
(*.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(literal 2 binary64)) (log.f64 im))
(/.f64 (-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re))))))) (log.f64 #s(literal 10 binary64)))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) #s(literal -1 binary64)))
(/.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 (.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1 binary64)) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(pow.f64 (pow.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(/.f64 (*.f64 (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(.f64 (pow.f64 (sqrt.f64 #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 (sqrt.f64 (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(-.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re (.f64 re (.f64 re re)))) (.f64 (.f64 im (.f64 im im)) (.f64 im (.f64 im im)))))) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re (.f64 re (.f64 re re)) (.f64 (.f64 im im) (.f64 (+.f64 re im) (-.f64 im re)))))) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 10 binary64)))
(pow.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))) #s(literal -1/2 binary64))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) #s(literal -1/2 binary64)))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))))

Outputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))

Calls

8 calls:

41.0ms	(*.f64 re re)
37.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
36.0ms	(+.f64 (.f64 re re) (.f64 im im))
18.0ms	im
12.0ms	re

Results

Accuracy	Segments	Branch
99.0%	1	`re`
99.0%	1	`im`
99.0%	1	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
99.0%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
99.0%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
99.0%	1	`(+.f64 (.f64 re re) (.f64 im im))`
99.0%	1	`(*.f64 re re)`
99.0%	1	`(*.f64 im im)`

Compiler

Compiled 60 to 38 computations (36.7% saved)

regimes115.0ms (1.2%)

Memory

-23.3MiB live, 97.2MiB allocated

Counts

21 → 1

Calls

Call 1

Inputs
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 (log.f64 (*.f64 (sqrt.f64 im) (sqrt.f64 (+.f64 re im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 (.f64 (sqrt.f64 #s(literal 1/2 binary64)) (sqrt.f64 #s(literal 1/2 binary64))) (/.f64 (log.f64 (fma.f64 im im (*.f64 re re))) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 (.f64 (sqrt.f64 (/.f64 (fma.f64 im im (.f64 re re)) (+.f64 re im))) (sqrt.f64 (+.f64 re im)))) (log.f64 #s(literal 10 binary64)))

Outputs
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))

Calls

8 calls:

30.0ms	im
28.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
6.0ms	re
6.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
6.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))

Results

Accuracy	Segments	Branch
98.3%	1	`re`
98.3%	1	`im`
98.3%	1	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
98.3%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
98.3%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
98.3%	1	`(+.f64 (.f64 re re) (.f64 im im))`
98.3%	1	`(*.f64 re re)`
98.3%	1	`(*.f64 im im)`

Compiler

Compiled 60 to 38 computations (36.7% saved)

regimes81.0ms (0.9%)

Memory

-11.5MiB live, 65.8MiB allocated

Counts

12 → 1

Calls

Call 1

Inputs
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))

Outputs
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))

Calls

8 calls:

30.0ms	re
28.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
4.0ms	im
4.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
4.0ms	(*.f64 im im)

Results

Accuracy	Segments	Branch
97.9%	1	`re`
97.9%	1	`im`
97.9%	1	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
97.9%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
97.9%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
97.9%	1	`(+.f64 (.f64 re re) (.f64 im im))`
97.9%	1	`(*.f64 re re)`
97.9%	1	`(*.f64 im im)`

Compiler

Compiled 60 to 38 computations (36.7% saved)

regimes40.0ms (0.4%)

Memory

6.5MiB live, 47.1MiB allocated

Counts

8 → 1

Calls

Call 1

Inputs
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))

Outputs
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))

Calls

8 calls:

19.0ms	(*.f64 re re)
3.0ms	im
3.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
3.0ms	re
3.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))

Results

Accuracy	Segments	Branch
97.9%	1	`re`
97.9%	1	`(*.f64 re re)`
97.9%	1	`im`
97.9%	1	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
97.9%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
97.9%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
97.9%	1	`(+.f64 (.f64 re re) (.f64 im im))`
97.9%	1	`(*.f64 im im)`

Compiler

Compiled 60 to 38 computations (36.7% saved)

regimes53.0ms (0.6%)

Memory

2.7MiB live, 40.3MiB allocated

Accuracy

Total -0.5b remaining (-36%)

Threshold costs -0.5b (-36%)

Counts

6 → 1

Calls

Call 1

Inputs
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 im))
(*.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))
(*.f64 (neg.f64 (log.f64 im)) (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))

Outputs
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))

Calls

8 calls:

35.0ms	(*.f64 re re)
2.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
2.0ms	re
2.0ms	im
2.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))

Results

Accuracy	Segments	Branch
97.9%	1	`re`
97.9%	1	`(*.f64 re re)`
97.9%	1	`im`
97.9%	1	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
97.9%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
97.9%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
97.9%	1	`(+.f64 (.f64 re re) (.f64 im im))`
97.9%	1	`(*.f64 im im)`

Compiler

Compiled 60 to 38 computations (36.7% saved)

simplify6.0ms (0.1%)

Memory

13.7MiB live, 13.7MiB allocated

Algorithm

1×	egg-herbie

Rules

4×	`*-commutative_binary64`
2×	`1-exp_binary64`
2×	`1-exp_binary32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	21	40
1	26	40

Stop Event

1×

saturated

Calls

Call 1

Inputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))

Outputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (fma.f64 re (*.f64 re (/.f64 #s(literal 1/2 binary64) im)) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 #s(literal 1 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))

soundness653.0ms (7%)

Memory

-4.4MiB live, 434.9MiB allocated

Rules

14 804×	`lower-fma.f64`
14 804×	`lower-fma.f32`
7 598×	`lower-fma.f32`
7 594×	`lower-fma.f64`
5 666×	`lower-*.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	10	38
0	17	38
1	44	38
2	251	38
3	2046	38
0	8387	22
0	30	193
0	58	131
1	183	126
2	1134	126
0	8665	126
0	27	102
0	49	89
1	148	82
2	783	81
3	5941	81
0	8391	81
0	268	1640
1	730	1596
2	2198	1594
3	5817	1582
0	8414	1470

Stop Event

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

Compiler

Compiled 125 to 86 computations (31.2% saved)

preprocess109.0ms (1.2%)

Memory

-10.3MiB live, 104.7MiB allocated

Remove

(sort re im)

(abs re)

(abs im)

Compiler

Compiled 220 to 146 computations (33.6% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

Iter	Nodes	Cost
0	24	62
1	50	62
2	96	62
3	173	62
4	238	62
5	260	62
6	271	62
7	282	62
8	285	62
9	286	62
0	10	12
0	17	12
1	18	12
0	18	7

Iter	Nodes	Cost
0	24	62
1	50	62
2	96	62
3	173	62
4	238	62
5	260	62
6	271	62
7	282	62
8	285	62
9	286	62
0	10	12
0	17	12
1	18	12
0	18	7

analyze62.0ms (0.7%)

sample974.0ms (10.4%)

preprocess21.0ms (0.2%)

explain185.0ms (2%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify4.0ms (0%)

localize38.0ms (0.4%)

series14.0ms (0.2%)

rewrite303.0ms (3.2%)

simplify507.0ms (5.4%)

eval60.0ms (0.6%)

prune121.0ms (1.3%)

simplify13.0ms (0.1%)

localize133.0ms (1.4%)

series136.0ms (1.5%)

rewrite424.0ms (4.5%)

simplify522.0ms (5.6%)

eval215.0ms (2.3%)

prune201.0ms (2.1%)

simplify73.0ms (0.8%)

localize119.0ms (1.3%)

series122.0ms (1.3%)

rewrite461.0ms (4.9%)

simplify479.0ms (5.1%)

eval388.0ms (4.2%)

prune643.0ms (6.9%)

simplify535.0ms (5.7%)

localize140.0ms (1.5%)

series83.0ms (0.9%)

rewrite286.0ms (3.1%)

simplify412.0ms (4.4%)

eval125.0ms (1.3%)

prune313.0ms (3.4%)

regimes179.0ms (1.9%)

regimes115.0ms (1.2%)

regimes81.0ms (0.9%)

regimes40.0ms (0.4%)

regimes53.0ms (0.6%)

simplify6.0ms (0.1%)

soundness653.0ms (7%)

preprocess109.0ms (1.2%)

end0.0ms (0%)

Profiling

Iter	Nodes	Cost
0	24	62
1	50	62
2	96	62
3	173	62
4	238	62
5	260	62
6	271	62
7	282	62
8	285	62
9	286	62
0	10	12
0	17	12
1	18	12
0	18	7