Metrics for math.log10 on complex, real part

start0.0ms (0%)

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

analyze65.0ms (1.5%)

Memory

-11.2MiB live, 71.6MiB allocated; 16ms collecting garbage

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)

sample1.1s (26.2%)

Memory

60.2MiB live, 935.5MiB allocated; 752ms collecting garbage

Samples

875.0ms

8 256×

valid

Precisions

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

ival-hypot: 163.0ms (41.7% of total)

ival-log: 160.0ms (40.9% of total)

ival-div: 57.0ms (14.6% of total)

exact: 5.0ms (1.3% of total)

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

adjust: 2.0ms (0.5% of total)

Bogosity

explain311.0ms (7.3%)

Memory

-9.3MiB live, 134.6MiB allocated; 21ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Example	Subexpression
143	-	-	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
0	-	-	`(log.f64 #s(literal 10 binary64))`
0	-	-	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
0	-	-	`(*.f64 re re)`
0	-	-	`im`
0	-	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	-	`re`
0	-	-	`(*.f64 im im)`
0	-	-	`#s(literal 10 binary64)`
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	121	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	121
↳	`(*.f64 re re)`	overflow	71
↳	`(*.f64 im im)`	overflow	68
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	22	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	22
↳	`(*.f64 re re)`	underflow	53
↳	`(*.f64 im im)`	underflow	72

Confusion

	Predicted +	Predicted -
+	143	0
-	0	113

Precision

1.0

Recall

1.0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	143	0	0
-	0	0	113

Precision?

1.0

Recall?

1.0

Freqs

test

number	freq
0	113
1	143

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

47.0ms

512×

valid

Compiler

Compiled 110 to 34 computations (69.1% saved)

Precisions

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

ival-log: 10.0ms (32% of total)

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

ival-mult: 7.0ms (22.4% of total)

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

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

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

preprocess20.0ms (0.5%)

Memory

-23.0MiB live, 22.4MiB allocated; 4ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	28	74
1	60	74
2	110	74
3	135	74
4	173	74
0	10	12
0	17	12
1	28	12
2	67	12
3	124	12
4	161	12
0	161	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 (hypot.f64 im re)) (log.f64 #s(literal 10 binary64)))

Symmetry

(abs re)

(abs im)

(sort re im)

Compiler

Compiled 12 to 10 computations (16.7% saved)

eval0.0ms (0%)

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

prune0.0ms (0%)

Memory

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

Alt Table

Click to see full alt table

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

Compiler

Compiled 12 to 10 computations (16.7% saved)

series15.0ms (0.4%)

Memory

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

Counts

10 → 79

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
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ 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)))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole 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)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole 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))))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ 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)))))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx im #s(hole binary64 im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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

6 calls:

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

rewrite272.0ms (6.3%)

Memory

-33.1MiB live, 254.1MiB allocated; 69ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	360	2530
0	371	2390
1	2012	2358
0	9623	1900

Stop Event

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

Counts

89 → 221

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)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ 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)))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole 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)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole 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))))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ 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)))))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx im #s(hole binary64 im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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
(/.f64 (neg.f64 (neg.f64 (log.f64 (hypot.f64 im re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 10 binary64)))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
(log.f64 (hypot.f64 im re))
(pow.f64 (hypot.f64 im re) #s(literal 1 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (sqrt.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (sqrt.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64))) (sqrt.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))
(/.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) (sqrt.f64 (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) re)
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) im)
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 im))
(hypot.f64 (fabs.f64 (fabs.f64 re)) im)
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) (fabs.f64 re))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (fabs.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 (fabs.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (neg.f64 (fabs.f64 re)))
(hypot.f64 im (fabs.f64 (fabs.f64 re)))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im re)
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (neg.f64 (fabs.f64 im)))
(hypot.f64 re (fabs.f64 (fabs.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re im)
(exp.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)))
(/.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (neg.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (neg.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (neg.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (neg.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (neg.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (neg.f64 (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))))
(/.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (-.f64 (.f64 re re) (.f64 im im)))
(/.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (-.f64 (.f64 im im) (.f64 re re)))
(/.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64)))))
(/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64)))))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) (*.f64 re re))
(fma.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)) (*.f64 im im))
(fma.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
(-.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (.f64 re re) (.f64 im im))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (.f64 re re) (.f64 im im))))
(-.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (.f64 im im) (.f64 re re))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (.f64 im im) (.f64 re re))))
(-.f64 (.f64 re re) (.f64 (neg.f64 im) im))
(+.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 re im) #s(literal 2 binary64))))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 re im) #s(literal 2 binary64))))))
(+.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))))))
(+.f64 (.f64 im im) (.f64 re re))
(+.f64 (.f64 re re) (.f64 im im))
(*.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)))
(*.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)))
(*.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 re re)
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (fabs.f64 re) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(fabs.f64 (*.f64 re re))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))))
re
(*.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)))
(*.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)))
(*.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(*.f64 im im)
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 (fabs.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 im #s(literal 2 binary64))
(fabs.f64 (*.f64 im im))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 im) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 im) #s(literal 2 binary64))))
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 im #s(literal -2 binary64)) (/.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 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (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 re re) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 im #s(literal -2 binary64)))) (*.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 re re)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal -4 binary64)))) (.f64 re re) (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.f64 re re) (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) im)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 3 binary64))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal -3 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
#s(approx (+ (* re re) (* im im)) (fma.f64 im im (*.f64 re re)))
#s(approx (* re re) (*.f64 re re))
#s(approx re re)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (/.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 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.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))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) 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)))))))
#s(approx (sqrt (+ (* re re) (* im im))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) #s(literal 1 binary64)) re))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
#s(approx (+ (* re re) (* im im)) (.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (/.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)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64) (fma.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))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) 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)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))) #s(literal 1 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal -2 binary64)) (/.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 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (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 im im) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal -2 binary64)))) (*.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 im im)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal -4 binary64)))) (.f64 im im) (.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.f64 im im) (log.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 3 binary64))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal -3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (* im im) (*.f64 im im))
#s(approx im im)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (/.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 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.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))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (/.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)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) 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))))) (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))) #s(literal 1 binary64)) im))
#s(approx (+ (* re re) (* im im)) (.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (neg.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (/.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)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64) (fma.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))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (/.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))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) 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)))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))) #s(literal 1 binary64))))

eval30.0ms (0.7%)

Memory: 5.6MiB live, 51.2MiB allocated; 8ms collecting garbage
Compiler: Compiled 4 158 to 936 computations (77.5% saved)

prune6.0ms (0.1%)

Memory

23.6MiB live, 23.7MiB allocated; 0ms collecting garbage

Pruning

5 alts after pruning (5 fresh and 0 done)

	Pruned	Kept	Total
New	212	5	217
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	213	5	218

Accuracy

99.7%

Counts

218 → 5

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	45.6%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
▶	98.9%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
▶	99.2%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶	98.4%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶	98.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))

Compiler

Compiled 142 to 112 computations (21.1% saved)

series148.0ms (3.5%)

Memory

10.0MiB live, 149.0MiB allocated; 21ms collecting garbage

Counts

29 → 261

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 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))
#s(approx (sqrt (+ (* re re) (* im im))) im)
(/.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))
(*.f64 re re)
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 (hypot.f64 im re)))
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 re im) (/.f64 re im))
(/.f64 re im)
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(log.f64 im)

Outputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ 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)))))))
#s(approx re #s(hole binary64 re))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* 1/2 (/ (log (pow im 2)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 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)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* 1/2 (log (pow im 2)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (log (pow im 2))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (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)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log im) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (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))))) (log im))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 im))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ 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)))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (* (/ re im) (/ re im)) #s(hole binary64 (/ (pow re 2) (pow im 2))))
#s(approx (/ re im) #s(hole binary64 (/ re im)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole 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)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ 1 re)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole 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)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ 1 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 re))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole 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)))))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole 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))))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ -1 re)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole 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)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ -1 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole 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))))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ 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)))))))
#s(approx im #s(hole binary64 im))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* 1/2 (/ (log (pow re 2)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 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)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* 1/2 (log (pow re 2)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (log (pow re 2))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (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)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log re) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))) (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (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))))) (log re))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ 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)))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (log im) #s(hole binary64 (log im)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ 1 im)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -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)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ 1 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (log im) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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))))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ -1 im)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -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)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ -1 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -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))))))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))))
#s(approx (log im) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 im))))))

Calls

6 calls:

Time	Variable		Point	Expression
50.0ms	im	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ 1/2 (log 10)) (* (/ re im) (/ re im)) (/ re im) (/ (log im) (log 10)) (log im))
42.0ms	im	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ 1/2 (log 10)) (* (/ re im) (/ re im)) (/ re im) (/ (log im) (log 10)) (log im))
19.0ms	re	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ 1/2 (log 10)) (* (/ re im) (/ re im)) (/ re im) (/ (log im) (log 10)) (log im))
17.0ms	im	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ 1/2 (log 10)) (* (/ re im) (/ re im)) (/ re im) (/ (log im) (log 10)) (log im))
8.0ms	re	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ 1/2 (log 10)) (* (/ re im) (/ re im)) (/ re im) (/ (log im) (log 10)) (log im))

rewrite226.0ms (5.3%)

Memory

-1.0MiB live, 228.2MiB allocated; 33ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	808	7811
0	844	6870
1	4290	6697
0	10170	6410

Stop Event

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

Counts

290 → 435

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 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))
#s(approx (sqrt (+ (* re re) (* im im))) im)
(/.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))
(*.f64 re re)
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 (hypot.f64 im re)))
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 (/.f64 re im) (/.f64 re im))
(/.f64 re im)
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(log.f64 im)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ 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)))))))
#s(approx re #s(hole binary64 re))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* 1/2 (/ (log (pow im 2)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 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)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* 1/2 (log (pow im 2)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (log (pow im 2))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (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)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log im) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (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))))) (log im))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 im))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ 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)))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (* (/ re im) (/ re im)) #s(hole binary64 (/ (pow re 2) (pow im 2))))
#s(approx (/ re im) #s(hole binary64 (/ re im)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole 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)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ 1 re)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole 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)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ 1 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 re))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole 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)))))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole 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))))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ -1 re)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole 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)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ -1 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole 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))))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ 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)))))))
#s(approx im #s(hole binary64 im))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* 1/2 (/ (log (pow re 2)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 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)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* 1/2 (log (pow re 2)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (log (pow re 2))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (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)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log re) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))) (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (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))))) (log re))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ 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)))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (log im) #s(hole binary64 (log im)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ 1 im)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -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)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ 1 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (log im) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -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))))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole 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)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ -1 im)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -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)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ -1 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -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))))))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))))
#s(approx (log im) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 im))))))

Outputs
(.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 10 binary64)))
(neg.f64 (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 1/10 binary64))))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
(neg.f64 (neg.f64 (log.f64 (hypot.f64 im re))))
(log.f64 (hypot.f64 im re))
(pow.f64 (hypot.f64 im re) #s(literal 1 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (sqrt.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (sqrt.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) (sqrt.f64 (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))))
(/.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64))) (sqrt.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))
(/.f64 #s(literal 1 binary64) (pow.f64 (hypot.f64 im re) #s(literal -1 binary64)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im re)
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (log.f64 (hypot.f64 im re)))
re
im
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))
#s(approx (sqrt (+ (* im im) (* re re))) im)
(.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 10 binary64)))
(neg.f64 (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 1/10 binary64))))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
(neg.f64 (neg.f64 (log.f64 (hypot.f64 im re))))
(log.f64 (hypot.f64 im re))
#s(literal 1/2 binary64)
(-.f64 (log.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (log.f64 (-.f64 (.f64 im im) (.f64 re re))))
(-.f64 (log.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (log.f64 (-.f64 (.f64 re re) (.f64 im im))))
(-.f64 (log.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64)))) (log.f64 (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))))
(-.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (log.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))
(log.f64 (fma.f64 im im (*.f64 re re)))
(/.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (-.f64 (.f64 im im) (.f64 re re)))
(/.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (-.f64 (.f64 re re) (.f64 im im)))
(/.f64 (+.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64)))))
(/.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64)))))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) (*.f64 re re))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
(-.f64 (.f64 im im) (.f64 (neg.f64 re) re))
(-.f64 (.f64 re re) (.f64 (neg.f64 im) im))
(+.f64 (.f64 im im) (.f64 re re))
(+.f64 (.f64 re re) (.f64 im im))
(*.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 re re)
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (pow.f64 re #s(literal -1 binary64)) #s(literal -2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 re #s(literal -1 binary64)) #s(literal 2 binary64)))
(fabs.f64 (*.f64 re re))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))))
(.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (fma.f64 im im (.f64 re re))) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 10 binary64)))
(neg.f64 (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (log.f64 (hypot.f64 im re)))
(-.f64 #s(literal 0 binary64) (log.f64 (hypot.f64 im re)))
(log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1 binary64)))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
(neg.f64 (neg.f64 (log.f64 (hypot.f64 im re))))
(log.f64 (hypot.f64 im re))
(pow.f64 (hypot.f64 im re) #s(literal 1 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (sqrt.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (sqrt.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) (sqrt.f64 (+.f64 (pow.f64 im #s(literal 4 binary64)) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))))
(/.f64 (hypot.f64 (pow.f64 re #s(literal 3 binary64)) (pow.f64 im #s(literal 3 binary64))) (sqrt.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 re im) #s(literal 2 binary64))))))
(/.f64 #s(literal 1 binary64) (pow.f64 (hypot.f64 im re) #s(literal -1 binary64)))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im re)
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re im)
(exp.f64 (log.f64 (hypot.f64 im re)))
(neg.f64 (log.f64 #s(literal 10 binary64)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(/.f64 (fma.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (fma.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (fma.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (fma.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (pow.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))) (/.f64 (-.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (fma.f64 (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 re im) #s(literal 6 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (-.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))))
(fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 re im)) (/.f64 re im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(fma.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (/.f64 (.f64 #s(literal 2 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal 2 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(+.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 (neg.f64 (neg.f64 (/.f64 re im))) (neg.f64 (neg.f64 (/.f64 re im))))
(*.f64 (pow.f64 (/.f64 re im) #s(literal 1 binary64)) (pow.f64 (/.f64 re im) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 re im) #s(literal 1 binary64)) (/.f64 re im))
(*.f64 (neg.f64 (/.f64 re im)) (neg.f64 (/.f64 re im)))
(*.f64 (/.f64 re im) (/.f64 re im))
(pow.f64 (neg.f64 (/.f64 re im)) #s(literal 2 binary64))
(pow.f64 (/.f64 re im) #s(literal 2 binary64))
(/.f64 (*.f64 re (/.f64 re im)) im)
(/.f64 (*.f64 (/.f64 re im) re) im)
(/.f64 (neg.f64 (.f64 re re)) (neg.f64 (.f64 im im)))
(/.f64 (.f64 re re) (.f64 im im))
(fabs.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)))
(exp.f64 (-.f64 (.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 #s(literal 2 binary64) (log.f64 im))))
(exp.f64 (*.f64 (log.f64 (/.f64 re im)) #s(literal 2 binary64)))
(/.f64 (neg.f64 re) (neg.f64 im))
(/.f64 re im)
(sqrt.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)))
(fabs.f64 (neg.f64 (/.f64 re im)))
(fabs.f64 (/.f64 re im))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(.f64 (/.f64 (.f64 #s(literal 2 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(.f64 #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal 2 binary64) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 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 (neg.f64 (log.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(.f64 (.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 1/2 binary64))
(.f64 #s(literal 1/2 binary64) (.f64 #s(literal 2 binary64) (log.f64 im)))
(neg.f64 (neg.f64 (log.f64 im)))
(log.f64 im)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.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 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal -4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 re re) (.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 re re)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal -4 binary64)))) (.f64 re re) (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.f64 re re) (log.f64 im)))
#s(approx (sqrt (+ (* im im) (* re re))) im)
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 3 binary64))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal -3 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx re re)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.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 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal -4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 re re) (.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 re re)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal -4 binary64)))) (.f64 re re) (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.f64 re re) (log.f64 im)))
#s(approx (log (+ (* im im) (* re re))) (*.f64 #s(literal 2 binary64) (log.f64 im)))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 #s(literal 2 binary64) (log.f64 im) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (pow.f64 im #s(literal -2 binary64))) (.f64 re re) (*.f64 #s(literal 2 binary64) (log.f64 im))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (fma.f64 (fma.f64 #s(literal 1/3 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal -4 binary64)))) (.f64 re re) (pow.f64 im #s(literal -2 binary64))) (.f64 re re) (*.f64 #s(literal 2 binary64) (log.f64 im))))
#s(approx (+ (* im im) (* re re)) (*.f64 im im))
#s(approx (+ (* im im) (* re re)) (fma.f64 im im (*.f64 re re)))
#s(approx (* re re) (*.f64 re re))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 1/10 binary64))))) (*.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -4 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/6 binary64) (.f64 re re)) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64))))) (.f64 re re) (.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64) (.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal -2 binary64)))) (.f64 re re)) (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (.f64 (fma.f64 (fma.f64 #s(literal -1/6 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (.f64 (pow.f64 im #s(literal -4 binary64)) #s(literal 1/4 binary64))) (.f64 re re) (.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal -2 binary64)))) (.f64 re re)) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 re re)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal -4 binary64)))) (.f64 re re) (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.f64 re re) (log.f64 im)))
#s(approx (sqrt (+ (* im im) (* re re))) im)
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 3 binary64))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal -3 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (* (/ re im) (/ re im)) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))
#s(approx (/ re im) (/.f64 re im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.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 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (sqrt (+ (* im im) (* re re))) re)
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re))))))
#s(approx (log (+ (* im im) (* re re))) (*.f64 (log.f64 re) #s(literal 2 binary64)))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 re) #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re))))
#s(approx (log (+ (* im im) (* re re))) (fma.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) (/.f64 (.f64 im im) (.f64 re re)))))
#s(approx (log (+ (* im im) (* re re))) (fma.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))))))
#s(approx (+ (* im im) (* re re)) (*.f64 re re))
#s(approx (+ (* im im) (* re re)) (.f64 (+.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (-.f64 (/.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 re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (sqrt (+ (* im im) (* re re))) re)
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (*.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (.f64 re re)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.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 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 re) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re))))))
#s(approx (log (+ (* im im) (* re re))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal -2 binary64))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 re re))))
#s(approx (log (+ (* im im) (* re re))) (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) (/.f64 (.f64 im im) (.f64 re re)))))
#s(approx (log (+ (* im im) (* re re))) (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))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal -1/2 binary64) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal 1 binary64)))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.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))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 re) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.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 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal -4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (.f64 (/.f64 (pow.f64 re #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 im im)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal -4 binary64)))) (.f64 im im) (.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.f64 im im) (log.f64 re)))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 3 binary64))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal -3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx im im)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.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 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal -4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (.f64 (/.f64 (pow.f64 re #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 im im)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal -4 binary64)))) (.f64 im im) (.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.f64 im im) (log.f64 re)))
#s(approx (log (+ (* im im) (* re re))) (*.f64 (log.f64 re) #s(literal 2 binary64)))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 re) #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (pow.f64 re #s(literal -2 binary64))) (.f64 im im) (*.f64 (log.f64 re) #s(literal 2 binary64))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (fma.f64 (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 im im) (pow.f64 re #s(literal -2 binary64))) (.f64 im im) (*.f64 (log.f64 re) #s(literal 2 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (/.f64 (.f64 im im) (.f64 re re)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal -2 binary64)) (log.f64 #s(literal 1/10 binary64))))) (*.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal -4 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/6 binary64) (.f64 im im)) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal -2 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64) (.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal -2 binary64)))) (.f64 im im)) (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (.f64 (fma.f64 (fma.f64 (pow.f64 re #s(literal -4 binary64)) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/6 binary64) (.f64 im im)) (pow.f64 re #s(literal 6 binary64)))) (.f64 im im) (.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal -2 binary64)))) (.f64 im im)) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 im im)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal -4 binary64)))) (.f64 im im) (.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.f64 im im) (log.f64 re)))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 3 binary64))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal -3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) (.f64 im im)))
#s(approx (/ (log im) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (log im) (log.f64 im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.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)))) #s(literal 1/720 binary64) (.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (log.f64 im)))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 6 binary64)) #s(literal 1/16 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) #s(literal 1 binary64)) im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 6 binary64)) #s(literal 1/6 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (log.f64 im)))
#s(approx (log (+ (* im im) (* re re))) (*.f64 #s(literal 2 binary64) (log.f64 im)))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 #s(literal 2 binary64) (log.f64 im) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))
#s(approx (log (+ (* im im) (* re re))) (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) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))))
#s(approx (log (+ (* im im) (* re re))) (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 (pow.f64 (/.f64 re im) #s(literal 6 binary64)) #s(literal 1/3 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))))
#s(approx (+ (* im im) (* re re)) (.f64 (+.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1 binary64)) (.f64 im im)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (-.f64 (/.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))) (log.f64 im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) (log.f64 im)))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 6 binary64)) #s(literal 1/16 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) #s(literal 1 binary64)) im))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log im) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (log im) (log.f64 im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.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)))) #s(literal 1/720 binary64) (.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))))))
#s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 im) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 6 binary64)) #s(literal 1/16 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) #s(literal 1 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/6 binary64) (.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 6 binary64)) #s(literal 1/6 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))))))
#s(approx (log (+ (* im im) (* re re))) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal -2 binary64))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))
#s(approx (log (+ (* im im) (* re re))) (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) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))))
#s(approx (log (+ (* im im) (* re re))) (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 (pow.f64 (/.f64 re im) #s(literal 6 binary64)) #s(literal 1/3 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (fma.f64 #s(literal -1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal 1 binary64)))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.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))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))))))
#s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 im) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (pow.f64 (/.f64 re im) #s(literal 6 binary64)) #s(literal 1/16 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)))) #s(literal 1 binary64))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (+.f64 (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log im) (log 10)) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64))))
#s(approx (log im) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))

eval79.0ms (1.8%)

Memory: 17.9MiB live, 61.3MiB allocated; 6ms collecting garbage
Compiler: Compiled 8 761 to 1 219 computations (86.1% saved)

prune20.0ms (0.5%)

Memory

-6.6MiB live, 37.4MiB allocated; 8ms collecting garbage

Pruning

14 alts after pruning (9 fresh and 5 done)

	Pruned	Kept	Total
New	311	9	320
Fresh	0	0	0
Picked	0	5	5
Done	0	0	0
Total	311	14	325

Accuracy

100.0%

Counts

325 → 14

Alt Table

Click to see full alt table

Status	Accuracy	Program
	15.2%	(/.f64 (.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (log.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 re im) #s(literal 2 binary64))))))) (log.f64 #s(literal 10 binary64)))
	45.4%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	45.6%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
✓	98.9%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
▶	98.1%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.2%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	98.4%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
✓	98.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
	98.8%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (pow.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 re im) #s(literal 6 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (-.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))))
▶	98.3%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64)))))
▶	99.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64)))))
▶	98.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (-.f64 (pow.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))) (/.f64 (-.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)) (log.f64 #s(literal 10 binary64)))))
▶	43.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) (.f64 im im))))
	49.7%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (.f64 re re))))

Compiler

Compiled 767 to 492 computations (35.9% saved)

series184.0ms (4.3%)

Memory

-12.1MiB live, 290.7MiB allocated; 55ms collecting garbage

Counts

45 → 245

Calls

Call 1

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

Outputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* -1 (/ (log im) (log 1/10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* -1 (/ (log im) (log 1/10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* -1 (* (log 10) (log im)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* -1 (* (log 10) (log im))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))))))
#s(approx (* (pow (/ re im) 2) 1/2) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (pow (/ re im) 2) #s(hole binary64 (/ (pow re 2) (pow im 2))))
#s(approx (/ re im) #s(hole binary64 (/ re im)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log im) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (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))))) (log im))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 im))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ 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)))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (/ (* (pow im 2) (log im)) (log 10))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10)))))
#s(approx (/ (* 1/2 (* re re)) (log 10)) #s(hole binary64 (* 1/2 (/ (pow re 2) (log 10)))))
#s(approx (* 1/2 (* re re)) #s(hole binary64 (* 1/2 (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* (log 10) (log im))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2))) (* (log 10) (log im)))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (* -1 (/ (pow (log im) 2) (pow (log 10) 2)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 10) 2)))) (/ (pow (log im) 2) (pow (log 10) 2)))))
#s(approx (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) #s(hole binary64 (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 10) 2))))))
#s(approx (* (pow (/ re im) 2) (/ 1/2 (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (* -1 (/ (log im) (log 10)))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (+ (* -1 (/ (log im) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (* -1 (log im))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (pow im 2))) (log im))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (log im) (* (pow re 2) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (* (log 10) (log im)) (pow re 2))) (* 1/2 (/ (log 1/10) (pow im 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ 1 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 re))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole 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)))))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (log 10)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (log 10))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log 10)))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ (log 10) (pow im 2))) (/ (* (log 10) (log im)) (pow re 2))))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 10) 2))))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (* (pow re 4) (+ (* -1 (/ (pow (log im) 2) (* (pow re 4) (pow (log 10) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log 10) 2))))))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (log im) (* (pow re 2) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (log im) (pow re 2))) (* 1/2 (/ 1 (pow im 2)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ -1 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole 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))))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (/ (+ (* -1 (/ (* (pow im 2) (log im)) (log 1/10))) (* 1/2 (/ (pow re 2) (log 10)))) (pow im 2))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (/ (+ (* -1 (* (pow im 2) (* (log 10) (log im)))) (* 1/2 (* (pow re 2) (log 1/10)))) (pow im 2))))
#s(approx im #s(hole binary64 im))
#s(approx (* (log 10) (neg (log im))) #s(hole binary64 (* -1 (* (log 10) (log im)))))
#s(approx (neg (log im)) #s(hole binary64 (* -1 (log im))))
#s(approx (log im) #s(hole binary64 (log im)))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log re) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))) (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (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))))) (log re))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ 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)))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (/ (+ (* 1/2 (* (pow re 2) (log 10))) (* (pow im 2) (* (log 10) (log im)))) (pow im 2))))
#s(approx (* (log 10) (log im)) #s(hole binary64 (* (log 10) (log im))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (/ (+ (* -1 (/ (* (pow im 4) (pow (log im) 2)) (pow (log 10) 2))) (* 1/4 (/ (pow re 4) (pow (log 10) 2)))) (pow im 4))))
#s(approx (pow (/ (log im) (log 10)) 2) #s(hole binary64 (/ (pow (log im) 2) (pow (log 10) 2))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (/ (+ (* -1 (/ (* (pow im 2) (log im)) (log 10))) (* 1/2 (/ (pow re 2) (log 10)))) (pow im 2))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (/ (+ (* -1 (* (pow im 2) (log im))) (* 1/2 (pow re 2))) (pow im 2))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* (log 10) (log (/ 1 im)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))) (* (log 10) (log (/ 1 im))))))
#s(approx (* (log 10) (neg (log im))) #s(hole binary64 (* (log 10) (log (/ 1 im)))))
#s(approx (neg (log im)) #s(hole binary64 (log (/ 1 im))))
#s(approx (log im) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ 1 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* -1 (/ (* (pow im 2) (log (/ 1 im))) (log 10)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* -1 (* (log 10) (log (/ 1 im))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (+ (* -1 (* (log 10) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2))))))
#s(approx (* (log 10) (log im)) #s(hole binary64 (* -1 (* (log 10) (log (/ 1 im))))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (* -1 (/ (pow (log (/ 1 im)) 2) (pow (log 10) 2)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 10) 2)))) (/ (pow (log (/ 1 im)) 2) (pow (log 10) 2)))))
#s(approx (pow (/ (log im) (log 10)) 2) #s(hole binary64 (/ (pow (log (/ 1 im)) 2) (pow (log 10) 2))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (/ (log (/ 1 im)) (log 10))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log (/ 1 im)) (log 10)))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (log (/ 1 im))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))))))
#s(approx (* (log 10) (neg (log im))) #s(hole binary64 (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (neg (log im)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (log im) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 im))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ -1 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -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))))))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10)))))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2))) (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (* (log 10) (log im)) #s(hole binary64 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (* -1 (/ (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2) (pow (log 10) 2)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 10) 2)))) (/ (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2) (pow (log 10) 2)))))
#s(approx (pow (/ (log im) (log 10)) 2) #s(hole binary64 (/ (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2) (pow (log 10) 2))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (pow im 2))) (+ (log -1) (* -1 (log (/ -1 im)))))))

Calls

6 calls:

Time	Variable		Point	Expression
36.0ms	im	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (pow (/ re im) 2) 1/2) (pow (/ re im) 2) (/ re im) re im 2 1/2 (log 1/10) 1/10 (* (log 10) (neg (log im))) (log 10) 10 (neg (log im)) (log im) (* (log 10) (log 1/10)) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im) (/ (log im) (log 10)) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log im)) (* (log 10) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (* (pow (/ re im) 2) (/ 1/2 (log 10))) (/ 1/2 (log 10)) (pow (/ (log im) (log 10)) 2) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (- (* (pow (/ re im) 2) 1/2) (log im)))
35.0ms	im	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (pow (/ re im) 2) 1/2) (pow (/ re im) 2) (/ re im) re im 2 1/2 (log 1/10) 1/10 (* (log 10) (neg (log im))) (log 10) 10 (neg (log im)) (log im) (* (log 10) (log 1/10)) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im) (/ (log im) (log 10)) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log im)) (* (log 10) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (* (pow (/ re im) 2) (/ 1/2 (log 10))) (/ 1/2 (log 10)) (pow (/ (log im) (log 10)) 2) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (- (* (pow (/ re im) 2) 1/2) (log im)))
31.0ms	re	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (pow (/ re im) 2) 1/2) (pow (/ re im) 2) (/ re im) re im 2 1/2 (log 1/10) 1/10 (* (log 10) (neg (log im))) (log 10) 10 (neg (log im)) (log im) (* (log 10) (log 1/10)) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im) (/ (log im) (log 10)) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log im)) (* (log 10) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (* (pow (/ re im) 2) (/ 1/2 (log 10))) (/ 1/2 (log 10)) (pow (/ (log im) (log 10)) 2) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (- (* (pow (/ re im) 2) 1/2) (log im)))
27.0ms	re	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (pow (/ re im) 2) 1/2) (pow (/ re im) 2) (/ re im) re im 2 1/2 (log 1/10) 1/10 (* (log 10) (neg (log im))) (log 10) 10 (neg (log im)) (log im) (* (log 10) (log 1/10)) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im) (/ (log im) (log 10)) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log im)) (* (log 10) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (* (pow (/ re im) 2) (/ 1/2 (log 10))) (/ 1/2 (log 10)) (pow (/ (log im) (log 10)) 2) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (- (* (pow (/ re im) 2) 1/2) (log im)))
25.0ms	im	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (pow (/ re im) 2) 1/2) (pow (/ re im) 2) (/ re im) re im 2 1/2 (log 1/10) 1/10 (* (log 10) (neg (log im))) (log 10) 10 (neg (log im)) (log im) (* (log 10) (log 1/10)) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im) (/ (log im) (log 10)) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log im)) (* (log 10) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (* (pow (/ re im) 2) (/ 1/2 (log 10))) (/ 1/2 (log 10)) (pow (/ (log im) (log 10)) 2) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (- (* (pow (/ re im) 2) 1/2) (log im)))

rewrite280.0ms (6.5%)

Memory

28.0MiB live, 208.3MiB allocated; 39ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	840	8754
0	921	7972
1	4436	7824
0	8539	6996

Stop Event

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

Counts

290 → 509

Calls

Call 1

Inputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (fma.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(fma.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))
(*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))
(pow.f64 (/.f64 re im) #s(literal 2 binary64))
(/.f64 re im)
re
im
#s(literal 2 binary64)
#s(literal 1/2 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(neg.f64 (log.f64 im))
(log.f64 im)
(*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)))
(log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))
#s(approx (sqrt (+ (* im im) (* re re))) im)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) (.f64 im im))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) (.f64 im im)))
(/.f64 (fma.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) (.f64 im im))
(fma.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (*.f64 re re)) (log.f64 #s(literal 10 binary64))))
(*.f64 im im)
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (log.f64 #s(literal 10 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 re re))
(*.f64 re re)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64)))))
(/.f64 (fma.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64))))
(fma.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (-.f64 (pow.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))) (/.f64 (-.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)) (log.f64 #s(literal 10 binary64)))))
(/.f64 (-.f64 (pow.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))) (/.f64 (-.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(-.f64 (pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)))
(pow.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
(*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))
(/.f64 (-.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(-.f64 (*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64)) (log.f64 im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* -1 (/ (log im) (log 1/10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* -1 (/ (log im) (log 1/10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* -1 (* (log 10) (log im)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* -1 (* (log 10) (log im))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))))))
#s(approx (* (pow (/ re im) 2) 1/2) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (pow (/ re im) 2) #s(hole binary64 (/ (pow re 2) (pow im 2))))
#s(approx (/ re im) #s(hole binary64 (/ re im)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log im) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (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))))) (log im))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 im))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ 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)))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (/ (* (pow im 2) (log im)) (log 10))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10)))))
#s(approx (/ (* 1/2 (* re re)) (log 10)) #s(hole binary64 (* 1/2 (/ (pow re 2) (log 10)))))
#s(approx (* 1/2 (* re re)) #s(hole binary64 (* 1/2 (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* (log 10) (log im))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2))) (* (log 10) (log im)))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (* -1 (/ (pow (log im) 2) (pow (log 10) 2)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 10) 2)))) (/ (pow (log im) 2) (pow (log 10) 2)))))
#s(approx (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) #s(hole binary64 (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 10) 2))))))
#s(approx (* (pow (/ re im) 2) (/ 1/2 (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (* -1 (/ (log im) (log 10)))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (+ (* -1 (/ (log im) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (* -1 (log im))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (pow im 2))) (log im))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (log im) (* (pow re 2) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (* (log 10) (log im)) (pow re 2))) (* 1/2 (/ (log 1/10) (pow im 2)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ 1 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 re))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole 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)))))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (log 10)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (log 10))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log 10)))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ (log 10) (pow im 2))) (/ (* (log 10) (log im)) (pow re 2))))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 10) 2))))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (* (pow re 4) (+ (* -1 (/ (pow (log im) 2) (* (pow re 4) (pow (log 10) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log 10) 2))))))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (log im) (* (pow re 2) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (log im) (pow re 2))) (* 1/2 (/ 1 (pow im 2)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 re)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ -1 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole 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))))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (/ (+ (* -1 (/ (* (pow im 2) (log im)) (log 1/10))) (* 1/2 (/ (pow re 2) (log 10)))) (pow im 2))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (/ (+ (* -1 (* (pow im 2) (* (log 10) (log im)))) (* 1/2 (* (pow re 2) (log 1/10)))) (pow im 2))))
#s(approx im #s(hole binary64 im))
#s(approx (* (log 10) (neg (log im))) #s(hole binary64 (* -1 (* (log 10) (log im)))))
#s(approx (neg (log im)) #s(hole binary64 (* -1 (log im))))
#s(approx (log im) #s(hole binary64 (log im)))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (* -1 (/ (log re) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (* -1 (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))) (log re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* (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))))) (log re))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (+ 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)))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (/ (+ (* 1/2 (* (pow re 2) (log 10))) (* (pow im 2) (* (log 10) (log im)))) (pow im 2))))
#s(approx (* (log 10) (log im)) #s(hole binary64 (* (log 10) (log im))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (/ (+ (* -1 (/ (* (pow im 4) (pow (log im) 2)) (pow (log 10) 2))) (* 1/4 (/ (pow re 4) (pow (log 10) 2)))) (pow im 4))))
#s(approx (pow (/ (log im) (log 10)) 2) #s(hole binary64 (/ (pow (log im) 2) (pow (log 10) 2))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (/ (+ (* -1 (/ (* (pow im 2) (log im)) (log 10))) (* 1/2 (/ (pow re 2) (log 10)))) (pow im 2))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (/ (+ (* -1 (* (pow im 2) (log im))) (* 1/2 (pow re 2))) (pow im 2))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* (log 10) (log (/ 1 im)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))) (* (log 10) (log (/ 1 im))))))
#s(approx (* (log 10) (neg (log im))) #s(hole binary64 (* (log 10) (log (/ 1 im)))))
#s(approx (neg (log im)) #s(hole binary64 (log (/ 1 im))))
#s(approx (log im) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ 1 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* 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)))))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* -1 (/ (* (pow im 2) (log (/ 1 im))) (log 10)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* -1 (* (log 10) (log (/ 1 im))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (+ (* -1 (* (log 10) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2))))))
#s(approx (* (log 10) (log im)) #s(hole binary64 (* -1 (* (log 10) (log (/ 1 im))))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (* -1 (/ (pow (log (/ 1 im)) 2) (pow (log 10) 2)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 10) 2)))) (/ (pow (log (/ 1 im)) 2) (pow (log 10) 2)))))
#s(approx (pow (/ (log im) (log 10)) 2) #s(hole binary64 (/ (pow (log (/ 1 im)) 2) (pow (log 10) 2))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (/ (log (/ 1 im)) (log 10))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log (/ 1 im)) (log 10)))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (log (/ 1 im))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))))))
#s(approx (* (log 10) (neg (log im))) #s(hole binary64 (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (neg (log im)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (log im) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 im))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 im)) (log 1/10))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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))))))
#s(approx (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) #s(hole 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)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (log (/ -1 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* im im) (* re re))) #s(hole binary64 (* -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))))))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10)))))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2))) (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (* (log 10) (log im)) #s(hole binary64 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))))
#s(approx (/ (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (* -1 (/ (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2) (pow (log 10) 2)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 10) 2)))) (/ (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2) (pow (log 10) 2)))))
#s(approx (pow (/ (log im) (log 10)) 2) #s(hole binary64 (/ (pow (+ (log -1) (* -1 (log (/ -1 im)))) 2) (pow (log 10) 2))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10)))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) #s(hole binary64 (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) #s(hole binary64 (- (* 1/2 (/ (pow re 2) (pow im 2))) (+ (log -1) (* -1 (log (/ -1 im)))))))

Outputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (/.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 10 binary64))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (/.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 10 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 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 #s(literal 10 binary64)))))
(/.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(+.f64 (/.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64)))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64)))))
(/.f64 (-.f64 (pow.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))) (log.f64 (/.f64 (pow.f64 (pow.f64 #s(literal 1/10 binary64) #s(literal 1/2 binary64)) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (pow.f64 im (log.f64 #s(literal 1/10 binary64))))))
(/.f64 (+.f64 (pow.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64)))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64)))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64)))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))))
(fma.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(fma.f64 (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(fma.f64 (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(fma.f64 #s(literal -1 binary64) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(fma.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(fma.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(-.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im))))
(+.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64)))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(+.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64)))))
(log.f64 (*.f64 (pow.f64 (pow.f64 #s(literal 1/10 binary64) #s(literal 1/2 binary64)) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (pow.f64 im (log.f64 #s(literal 1/10 binary64)))))
(log.f64 (*.f64 (pow.f64 im (log.f64 #s(literal 1/10 binary64))) (pow.f64 (pow.f64 #s(literal 1/10 binary64) #s(literal 1/2 binary64)) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))))
(*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))
(*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64))
(/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im))
(*.f64 (neg.f64 (neg.f64 (/.f64 re im))) (neg.f64 (neg.f64 (/.f64 re im))))
(*.f64 (neg.f64 (fabs.f64 (/.f64 re im))) (neg.f64 (fabs.f64 (/.f64 re im))))
(*.f64 (fabs.f64 (fabs.f64 (/.f64 re im))) (fabs.f64 (fabs.f64 (/.f64 re im))))
(*.f64 (exp.f64 (log.f64 (/.f64 re im))) (exp.f64 (log.f64 (/.f64 re im))))
(*.f64 (neg.f64 (/.f64 re im)) (neg.f64 (/.f64 re im)))
(*.f64 (fabs.f64 (/.f64 re im)) (fabs.f64 (/.f64 re im)))
(*.f64 (/.f64 re im) (/.f64 re im))
(pow.f64 (exp.f64 (log.f64 (/.f64 re im))) #s(literal 2 binary64))
(pow.f64 (neg.f64 (/.f64 re im)) #s(literal 2 binary64))
(pow.f64 (fabs.f64 (/.f64 re im)) #s(literal 2 binary64))
(pow.f64 (/.f64 re im) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1 binary64))
(/.f64 (*.f64 re (/.f64 re im)) im)
(/.f64 (*.f64 (/.f64 re im) re) im)
(/.f64 (neg.f64 (.f64 re re)) (neg.f64 (.f64 im im)))
(/.f64 (.f64 re re) (.f64 im im))
(fabs.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)))
(exp.f64 (-.f64 (.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 (log.f64 im) #s(literal 2 binary64))))
(exp.f64 (*.f64 (log.f64 (/.f64 re im)) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 (/.f64 re im)) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 (/.f64 re im)) #s(literal 2 binary64))))
(pow.f64 (/.f64 re im) #s(literal 1 binary64))
(/.f64 (neg.f64 re) (neg.f64 im))
(/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 re im) #s(literal -1 binary64)))
(/.f64 re im)
(exp.f64 (*.f64 (log.f64 (/.f64 re im)) #s(literal 1 binary64)))
re
im
#s(literal 2 binary64)
#s(literal 1/2 binary64)
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 10 binary64)))
(neg.f64 (log.f64 #s(literal 10 binary64)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 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 #s(literal -1 binary64) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))
(neg.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(log.f64 (pow.f64 #s(literal 10 binary64) (neg.f64 (log.f64 im))))
(log.f64 (pow.f64 (pow.f64 im (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(log.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im (log.f64 #s(literal 10 binary64)))))
(log.f64 (pow.f64 im (log.f64 #s(literal 1/10 binary64))))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(*.f64 #s(literal -1 binary64) (log.f64 im))
(*.f64 (log.f64 im) #s(literal -1 binary64))
(pow.f64 (neg.f64 (log.f64 im)) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64)))
(neg.f64 (log.f64 im))
(-.f64 #s(literal 0 binary64) (log.f64 im))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (neg.f64 im)))
(exp.f64 (*.f64 (log.f64 (neg.f64 (log.f64 im))) #s(literal 1 binary64)))
(log.f64 (pow.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)))
(pow.f64 (log.f64 im) #s(literal 1 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1 binary64)))
(neg.f64 (neg.f64 (log.f64 im)))
(exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 1 binary64)))
(log.f64 im)
(*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64)))
(log.f64 (pow.f64 #s(literal 10 binary64) (log.f64 #s(literal 1/10 binary64))))
(log.f64 (pow.f64 #s(literal 1/10 binary64) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im)))
(log.f64 (pow.f64 #s(approx (sqrt (+ (* im im) (* re re))) im) #s(literal -1 binary64)))
(log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))
#s(approx (sqrt (+ (* im im) (* re re))) im)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (.f64 im im))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (.f64 im im)))
(/.f64 (/.f64 (fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (*.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) im) im)
(/.f64 (neg.f64 (fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))) (neg.f64 (.f64 im im)))
(/.f64 (fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (.f64 im im))
(+.f64 (/.f64 (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (.f64 im im)) (/.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 im im)))
(+.f64 (/.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 im im)) (/.f64 (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (.f64 im im)))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (pow.f64 (/.f64 (.f64 (.f64 im im) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64))) (-.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
(/.f64 (-.f64 (pow.f64 (/.f64 (.f64 (.f64 im im) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (pow.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))) (-.f64 (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))))
(/.f64 (fma.f64 (pow.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) #s(literal 1/8 binary64) (.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 im #s(literal 6 binary64)))) (+.f64 (pow.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (/.f64 (.f64 (.f64 im im) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (*.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))))
(/.f64 (fma.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64)) (pow.f64 im #s(literal 6 binary64)) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/8 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 3 binary64)))) (+.f64 (pow.f64 (/.f64 (.f64 (.f64 im im) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (.f64 (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))))))
(fma.f64 (/.f64 (.f64 (.f64 im im) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))))
(fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (*.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(fma.f64 #s(literal -1 binary64) (/.f64 (.f64 (.f64 im im) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))))
(fma.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (*.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))))
(fma.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (.f64 im im) (/.f64 (.f64 (*.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))))
(fma.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) (.f64 (*.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(fma.f64 im (.f64 im (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (*.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))))
(-.f64 (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64)))))
(+.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+.f64 (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))))
(*.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)))
(*.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)))
(*.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(*.f64 im im)
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 (fabs.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 im #s(literal 2 binary64))
(fabs.f64 (*.f64 im im))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 im) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 im) #s(literal 2 binary64))))
(*.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(neg.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 1 binary64)))
(.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(.f64 #s(literal 1/2 binary64) (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))
(/.f64 (neg.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(.f64 (.f64 #s(literal 1/2 binary64) re) re)
(.f64 (.f64 re re) #s(literal 1/2 binary64))
(.f64 #s(literal 1/2 binary64) (.f64 re re))
(*.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)))
(*.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)))
(*.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 re re)
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (fabs.f64 re) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(fabs.f64 (*.f64 re re))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (/.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (log.f64 #s(literal 10 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(+.f64 (/.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (/.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (-.f64 (pow.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))) (log.f64 (/.f64 (pow.f64 (pow.f64 #s(literal 10 binary64) #s(literal 1/2 binary64)) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (pow.f64 im (log.f64 #s(literal 10 binary64))))))
(/.f64 (+.f64 (pow.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)) (.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))))
(fma.f64 (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(fma.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(fma.f64 (log.f64 #s(literal 10 binary64)) (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(fma.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(-.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(+.f64 (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))) (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (*.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))))
(log.f64 (*.f64 (pow.f64 (pow.f64 #s(literal 10 binary64) #s(literal 1/2 binary64)) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (pow.f64 im (log.f64 #s(literal 10 binary64)))))
(log.f64 (*.f64 (pow.f64 im (log.f64 #s(literal 10 binary64))) (pow.f64 (pow.f64 #s(literal 10 binary64) #s(literal 1/2 binary64)) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))))
(*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(log.f64 (pow.f64 #s(literal 10 binary64) (log.f64 im)))
(log.f64 (pow.f64 im (log.f64 #s(literal 10 binary64))))
(*.f64 (neg.f64 (fabs.f64 (log.f64 #s(literal 1/10 binary64)))) (neg.f64 (fabs.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (fabs.f64 (fabs.f64 (log.f64 #s(literal 1/10 binary64)))) (fabs.f64 (fabs.f64 (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))) (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))))
(*.f64 (fabs.f64 (log.f64 #s(literal 1/10 binary64))) (fabs.f64 (log.f64 #s(literal 1/10 binary64))))
(*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 1/10 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64)))
(pow.f64 (exp.f64 (log.f64 (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
(pow.f64 (fabs.f64 (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))
(fabs.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))))
(log.f64 (pow.f64 #s(literal 10 binary64) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(.f64 (/.f64 (-.f64 (.f64 (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (pow.f64 (/.f64 re im) #s(literal 4 binary64))) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64))) (-.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im))) (log.f64 #s(literal 10 binary64)))
(/.f64 (+.f64 (pow.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64))) (fma.f64 (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (pow.f64 (/.f64 re im) #s(literal 4 binary64)) (-.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))))
(/.f64 (neg.f64 (-.f64 (.f64 (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (pow.f64 (/.f64 re im) #s(literal 4 binary64))) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)))) (neg.f64 (/.f64 (-.f64 (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))))
(/.f64 (-.f64 (.f64 (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (pow.f64 (/.f64 re im) #s(literal 4 binary64))) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64))) (/.f64 (-.f64 (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(fma.f64 (pow.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 re im)) #s(literal 1 binary64)) (/.f64 re im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(fma.f64 (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(fma.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 re im)) (/.f64 re im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(fma.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64) (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))
(fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (.f64 (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (pow.f64 (/.f64 re im) #s(literal 4 binary64))) (/.f64 (-.f64 (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))) (/.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))))
(+.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))
(log.f64 (pow.f64 #s(literal 10 binary64) (/.f64 (-.f64 (.f64 (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (pow.f64 (/.f64 re im) #s(literal 4 binary64))) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64))) (-.f64 (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) #s(literal 4 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 4 binary64))) (fma.f64 (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (pow.f64 (/.f64 re im) #s(literal 4 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64))))
(/.f64 (-.f64 (pow.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) #s(literal 6 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 6 binary64))) (+.f64 (pow.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) #s(literal 4 binary64)) (+.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 4 binary64)) (pow.f64 (.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))))
(-.f64 (*.f64 (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (pow.f64 (/.f64 re im) #s(literal 4 binary64))) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)))
(.f64 (neg.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))) (neg.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))))
(.f64 (fabs.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))) (fabs.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))))
(.f64 (exp.f64 (log.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))) (exp.f64 (log.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))))
(.f64 (pow.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 re im)) #s(literal 2 binary64)) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))
(*.f64 (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (pow.f64 (/.f64 re im) #s(literal 4 binary64)))
(*.f64 (pow.f64 (/.f64 re im) #s(literal 4 binary64)) (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)))
(.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))
(pow.f64 (exp.f64 (log.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))) #s(literal 2 binary64))
(pow.f64 (*.f64 (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) (pow.f64 (/.f64 re im) #s(literal 4 binary64))) #s(literal 1 binary64))
(pow.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) #s(literal 2 binary64))
(exp.f64 (.f64 (log.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))) #s(literal 2 binary64))))
(.f64 (pow.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 re im)) #s(literal 1 binary64)) (/.f64 re im))
(*.f64 (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))
(.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 re im)) (/.f64 re im))
(*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))
(*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (pow.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))
(pow.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) #s(literal 1 binary64))
(/.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1 binary64) (pow.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) #s(literal -1 binary64)))
(exp.f64 (.f64 (log.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) #s(literal 1/2 binary64))
(*.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)))
(/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 (fabs.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (fabs.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(*.f64 (fabs.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) (fabs.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
(*.f64 (exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 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 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(pow.f64 (exp.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) #s(literal 2 binary64))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))) #s(literal 2 binary64)) #s(literal 1 binary64))
(pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 2 binary64))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))))
(/.f64 (neg.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (-.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(-.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (pow.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (fma.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 im)))
(/.f64 (-.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/8 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) #s(literal 2 binary64)) (fma.f64 (log.f64 im) (log.f64 im) (.f64 (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im)))))
(fma.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (*.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im))))
(fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1/2 binary64) (*.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im))))
(-.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im))
(+.f64 (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.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 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 im #s(literal -4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 re re) (.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (fma.f64 (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re)) (.f64 im im)) #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
#s(approx (* (pow (/ re im) 2) 1/2) (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))
#s(approx (pow (/ re im) 2) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))
#s(approx (/ re im) (/.f64 re im))
#s(approx re re)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1/4 binary64) (.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -4 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/6 binary64) (.f64 re re)) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64))))) (.f64 re re) (.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64) (.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal -2 binary64)))) (.f64 re re)) (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (.f64 (fma.f64 (fma.f64 (pow.f64 im #s(literal -4 binary64)) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/6 binary64) (.f64 re re)) (pow.f64 im #s(literal 6 binary64)))) (.f64 re re) (.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal -2 binary64)))) (.f64 re re)) (log.f64 im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 re re)) (pow.f64 im #s(literal 4 binary64)))) (*.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal -4 binary64)))) (.f64 re re) (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.f64 re re) (log.f64 im)))
#s(approx (sqrt (+ (* im im) (* re re))) im)
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 3 binary64))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal -3 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (*.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (* 1/2 (* re re)) (log 10)) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))))
#s(approx (* 1/2 (* re re)) (.f64 (.f64 re re) #s(literal 1/2 binary64)))
#s(approx (* re re) (*.f64 re re))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (fma.f64 (/.f64 (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) (.f64 im im)) #s(literal 1/2 binary64) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (neg.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
#s(approx (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
#s(approx (* (pow (/ re im) 2) (/ 1/2 (log 10))) (*.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) (neg.f64 (log.f64 im)))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) (-.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.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 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (*.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (neg.f64 (log.f64 im)) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re)))) (.f64 re re)))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (.f64 (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re)) (.f64 im im)) #s(literal 1/2 binary64)))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (.f64 (fma.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 im im)) #s(literal 1/2 binary64) (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (.f64 re re))) (*.f64 re re)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re))) #s(literal -1/2 binary64) (fma.f64 (/.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)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 re))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (-.f64 (/.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 re)) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 re))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (sqrt (+ (* im im) (* re re))) re)
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (*.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (.f64 re re)))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (*.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (.f64 re re)))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))) (.f64 re re)))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (*.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (.f64 re re)))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (.f64 (/.f64 (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) (.f64 im im)) #s(literal 1/2 binary64)))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (.f64 (fma.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 im im)) #s(literal 1/2 binary64) (/.f64 (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (.f64 re re))) (*.f64 re re)))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (*.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (.f64 re re)))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1/4 binary64) (neg.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))) (pow.f64 re #s(literal 4 binary64))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (*.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (neg.f64 (log.f64 im)) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (.f64 re re)))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) (.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (neg.f64 (log.f64 im)) (.f64 re re))) (*.f64 re re)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.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 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re))) #s(literal -1/2 binary64) (fma.f64 (/.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)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal -1/2 binary64) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) re) #s(literal 1 binary64)))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.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))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 re))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 re) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.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 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (/.f64 (pow.f64 re #s(literal -4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (.f64 (/.f64 (pow.f64 re #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (/.f64 (fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (.f64 im im)))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (/.f64 (fma.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 1/10 binary64)) (neg.f64 (.f64 (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (.f64 im im)))) (.f64 im im)))
#s(approx im im)
#s(approx (* (log 10) (neg (log im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
#s(approx (neg (log im)) (neg.f64 (log.f64 im)))
#s(approx (log im) (log.f64 im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal -2 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal -4 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/6 binary64) (.f64 im im)) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (.f64 #s(literal -1/2 binary64) (/.f64 (pow.f64 re #s(literal -2 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64) (.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal -2 binary64)))) (.f64 im im)) (log.f64 re)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (.f64 (fma.f64 (fma.f64 (pow.f64 re #s(literal -4 binary64)) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/6 binary64) (.f64 im im)) (pow.f64 re #s(literal 6 binary64)))) (.f64 im im) (.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal -2 binary64)))) (.f64 im im)) (log.f64 re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 re))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (fma.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (.f64 im im)) (pow.f64 re #s(literal 4 binary64)))) (*.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal -4 binary64)))) (.f64 im im) (.f64 (pow.f64 re #s(literal -2 binary64)) #s(literal 1/2 binary64))) (*.f64 im im) (log.f64 re)))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 3 binary64))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 5 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal -3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (.f64 im im)))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/.f64 (fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (.f64 im im)))
#s(approx (* im im) (*.f64 im im))
#s(approx (/ (log im) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (/.f64 (fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (.f64 im im)))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (/.f64 (fma.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (.f64 im im))) (.f64 im im)))
#s(approx (* (log 10) (log im)) (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (.f64 im im)))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #s(literal 1/4 binary64) (neg.f64 (*.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))) (pow.f64 im #s(literal 4 binary64))))
#s(approx (pow (/ (log im) (log 10)) 2) (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (/.f64 (fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (.f64 (.f64 im im) (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))) (.f64 im im)))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) (/.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) re) re (.f64 (neg.f64 (log.f64 im)) (.f64 im im))) (.f64 im im)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.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)))) #s(literal 1/720 binary64) (.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (fma.f64 (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re)) (.f64 im im)) #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))))
#s(approx (* (log 10) (neg (log im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
#s(approx (neg (log im)) (neg.f64 (log.f64 im)))
#s(approx (log im) (log.f64 im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 im))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (-.f64 (/.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))) (log.f64 im)) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))) (log.f64 im)))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))) (log.f64 im)))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (fma.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))) #s(literal 1 binary64)) im))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (.f64 (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (.f64 im im)))
#s(approx (/ (log im) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (fma.f64 (/.f64 (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) (.f64 im im)) #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))))
#s(approx (* (log 10) (log im)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (neg.f64 (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
#s(approx (pow (/ (log im) (log 10)) 2) (/.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) (neg.f64 (log.f64 im)))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) (-.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (log.f64 im)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.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)))) #s(literal 1/720 binary64) (.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (fma.f64 (/.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re)) (.f64 im im)) #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))))
#s(approx (* (log 10) (neg (log im))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (neg (log im)) (neg.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (log im) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (*.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (fma.f64 #s(literal -1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 (pow.f64 (/.f64 #s(literal -1 binary64) im) #s(literal 1 binary64)))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.f64 (*.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))))
#s(approx (neg (log (sqrt (+ (* im im) (* re re))))) (-.f64 (/.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))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))))
#s(approx (log (sqrt (+ (* im im) (* re re)))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))))))
#s(approx (sqrt (+ (* im im) (* re re))) (neg.f64 im))
#s(approx (sqrt (+ (* im im) (* re re))) (*.f64 (neg.f64 im) (fma.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64)))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* im im) (* re re))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/16 binary64) (.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))))) #s(literal 1 binary64))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (+.f64 (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (+.f64 (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (.f64 (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64))) (.f64 im im)))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (.f64 (+.f64 (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))) (.f64 im im)))
#s(approx (/ (log im) (log 10)) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (+.f64 (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64)) (.f64 (/.f64 (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) (.f64 im im)) #s(literal 1/2 binary64))))
#s(approx (* (log 10) (log im)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (+.f64 (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal -1 binary64)) (log.f64 #s(literal 1/10 binary64)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (neg.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
#s(approx (- (pow (* (pow (/ re im) 2) (/ 1/2 (log 10))) 2) (pow (/ (log im) (log 10)) 2)) (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))))
#s(approx (pow (/ (log im) (log 10)) 2) (/.f64 (pow.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) #s(literal 2 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (- (* (pow (/ re im) 2) 1/2) (log im)) (log 10)) (fma.f64 (/.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) (neg.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))
#s(approx (- (* (pow (/ re im) 2) 1/2) (log im)) (-.f64 (*.f64 #s(literal 1/2 binary64) (pow.f64 (/.f64 re im) #s(literal 2 binary64))) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))))

eval128.0ms (3%)

Memory: -28.6MiB live, 119.5MiB allocated; 25ms collecting garbage
Compiler: Compiled 32 361 to 2 905 computations (91% saved)

prune61.0ms (1.4%)

Memory

-3.6MiB live, 44.0MiB allocated; 1ms collecting garbage

Pruning

19 alts after pruning (13 fresh and 6 done)

	Pruned	Kept	Total
New	706	12	718
Fresh	3	1	4
Picked	4	1	5
Done	0	5	5
Total	713	19	732

Accuracy

100.0%

Counts

732 → 19

Alt Table

Click to see full alt table

Status	Accuracy	Program
	45.4%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	45.6%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
✓	98.9%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
✓	98.1%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.2%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	98.4%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
✓	98.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
▶	83.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (.f64 im im)) (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64)))))
▶	99.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) #s(literal 1/2 binary64)) (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64)))))
	98.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (/.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 10 binary64))) (log.f64 #s(literal 1/10 binary64))))
▶	97.8%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64)))))
	49.7%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (.f64 re re))))
	49.5%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (neg.f64 (log.f64 im)) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re)))) (.f64 re re))))
	43.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1 binary64) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (*.f64 im im))))
	43.3%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (.f64 im im) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) (.f64 im im))))
	25.0%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (.f64 im im) (/.f64 (exp.f64 (.f64 (log.f64 (log.f64 im)) #s(literal 1 binary64))) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) (*.f64 im im))))
▶	43.3%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 im (.f64 im (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 im im))))
▶	2.7%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (*.f64 im im))))
	43.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (*.f64 im im))))

Compiler

Compiled 1 334 to 852 computations (36.1% saved)

series180.0ms (4.2%)

Memory

40.5MiB live, 226.5MiB allocated; 25ms collecting garbage

Counts

41 → 150

Calls

Call 1

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

Outputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* -1 (/ (log im) (log 1/10)))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* -1 (/ (log im) (log 1/10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* -1 (* (log 10) (log im)))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* -1 (* (log 10) (log im))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))))))
#s(approx (* (/ (* (/ re im) re) im) 1/2) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (/ (* (/ re im) re) im) #s(hole binary64 (/ (pow re 2) (pow im 2))))
#s(approx (* (/ re im) re) #s(hole binary64 (/ (pow re 2) im)))
#s(approx (/ re im) #s(hole binary64 (/ re im)))
#s(approx re #s(hole binary64 re))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (/ (* (pow im 2) (log im)) (log 10))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10)))))
#s(approx (/ (* (* re re) 1/2) (log 10)) #s(hole binary64 (* 1/2 (/ (pow re 2) (log 10)))))
#s(approx (* (* re re) 1/2) #s(hole binary64 (* 1/2 (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (/ (* (pow im 2) (log im)) (log 10))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* (log 10) (log im))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2))) (* (log 10) (log im)))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* -1 (/ (log im) (log 1/10)))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* -1 (/ (log im) (log 1/10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* -1 (* (log 10) (log im)))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* -1 (* (log 10) (log im))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))))))
#s(approx (/ (* (* re re) 1/2) (* im im)) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (log im) (* (pow re 2) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2)))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (* (log 10) (log im)) (pow re 2))) (* 1/2 (/ (log 1/10) (pow im 2)))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (log 10)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (log 10))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log 10)))))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (log 10)))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (log 10))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log 10)))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ (log 10) (pow im 2))) (/ (* (log 10) (log im)) (pow re 2))))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (log im) (* (pow re 2) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2)))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (* (log 10) (log im)) (pow re 2))) (* 1/2 (/ (log 1/10) (pow im 2)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (/ (+ (* -1 (/ (* (pow im 2) (log im)) (log 1/10))) (* 1/2 (/ (pow re 2) (log 10)))) (pow im 2))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (/ (+ (* -1 (* (pow im 2) (* (log 10) (log im)))) (* 1/2 (* (pow re 2) (log 1/10)))) (pow im 2))))
#s(approx im #s(hole binary64 im))
#s(approx (* (log 10) (neg (log im))) #s(hole binary64 (* -1 (* (log 10) (log im)))))
#s(approx (neg (log im)) #s(hole binary64 (* -1 (log im))))
#s(approx (log im) #s(hole binary64 (log im)))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (* im (/ (log im) (log 10))) #s(hole binary64 (/ (* im (log im)) (log 10))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (/ (+ (* 1/2 (* (pow re 2) (log 10))) (* (pow im 2) (* (log 10) (log im)))) (pow im 2))))
#s(approx (* (log im) (log 10)) #s(hole binary64 (* (log 10) (log im))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (/ (+ (* -1 (/ (* (pow im 2) (log im)) (log 1/10))) (* 1/2 (/ (pow re 2) (log 10)))) (pow im 2))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (/ (+ (* -1 (* (pow im 2) (* (log 10) (log im)))) (* 1/2 (* (pow re 2) (log 1/10)))) (pow im 2))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* (log 10) (log (/ 1 im)))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))) (* (log 10) (log (/ 1 im))))))
#s(approx (* (log 10) (neg (log im))) #s(hole binary64 (* (log 10) (log (/ 1 im)))))
#s(approx (neg (log im)) #s(hole binary64 (log (/ 1 im))))
#s(approx (log im) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* -1 (/ (* (pow im 2) (log (/ 1 im))) (log 10)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (* -1 (/ (* (pow im 2) (log (/ 1 im))) (log 10)))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (* im (/ (log im) (log 10))) #s(hole binary64 (* -1 (/ (* im (log (/ 1 im))) (log 10)))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* -1 (* (log 10) (log (/ 1 im))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (+ (* -1 (* (log 10) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2))))))
#s(approx (* (log im) (log 10)) #s(hole binary64 (* -1 (* (log 10) (log (/ 1 im))))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* (log 10) (log (/ 1 im)))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))) (* (log 10) (log (/ 1 im))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))))))
#s(approx (* (log 10) (neg (log im))) #s(hole binary64 (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (neg (log im)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (log im) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 im))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10)))))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10)))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10))))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10)))))))
#s(approx (* im (/ (log im) (log 10))) #s(hole binary64 (/ (* im (+ (log -1) (* -1 (log (/ -1 im))))) (log 10))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2))) (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (* (log im) (log 10)) #s(hole binary64 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))))))

Calls

6 calls:

Time	Variable		Point	Expression
56.0ms	im	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (/ (* (/ re im) re) im) 1/2) (/ (* (/ re im) re) im) (* (/ re im) re) (/ re im) re im 1/2 (log 1/10) 1/10 (* (log 10) (neg (log im))) (log 10) 10 (neg (log im)) (log im) (* (log 10) (log 1/10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/ (* (* re re) 1/2) (log 10)) (* (* re re) 1/2) (* re re) (* im im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im (/ (log im) (log 10))) (/ (log im) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log im) (log 10)) (* (log 10) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (/ (* (* re re) 1/2) (* im im)))
38.0ms	re	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (/ (* (/ re im) re) im) 1/2) (/ (* (/ re im) re) im) (* (/ re im) re) (/ re im) re im 1/2 (log 1/10) 1/10 (* (log 10) (neg (log im))) (log 10) 10 (neg (log im)) (log im) (* (log 10) (log 1/10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/ (* (* re re) 1/2) (log 10)) (* (* re re) 1/2) (* re re) (* im im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im (/ (log im) (log 10))) (/ (log im) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log im) (log 10)) (* (log 10) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (/ (* (* re re) 1/2) (* im im)))
28.0ms	im	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (/ (* (/ re im) re) im) 1/2) (/ (* (/ re im) re) im) (* (/ re im) re) (/ re im) re im 1/2 (log 1/10) 1/10 (* (log 10) (neg (log im))) (log 10) 10 (neg (log im)) (log im) (* (log 10) (log 1/10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/ (* (* re re) 1/2) (log 10)) (* (* re re) 1/2) (* re re) (* im im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im (/ (log im) (log 10))) (/ (log im) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log im) (log 10)) (* (log 10) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (/ (* (* re re) 1/2) (* im im)))
26.0ms	im	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (/ (* (/ re im) re) im) 1/2) (/ (* (/ re im) re) im) (* (/ re im) re) (/ re im) re im 1/2 (log 1/10) 1/10 (* (log 10) (neg (log im))) (log 10) 10 (neg (log im)) (log im) (* (log 10) (log 1/10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/ (* (* re re) 1/2) (log 10)) (* (* re re) 1/2) (* re re) (* im im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im (/ (log im) (log 10))) (/ (log im) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log im) (log 10)) (* (log 10) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (/ (* (* re re) 1/2) (* im im)))
14.0ms	re	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (/ (* (/ re im) re) im) 1/2) (/ (* (/ re im) re) im) (* (/ re im) re) (/ re im) re im 1/2 (log 1/10) 1/10 (* (log 10) (neg (log im))) (log 10) 10 (neg (log im)) (log im) (* (log 10) (log 1/10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/ (* (* re re) 1/2) (log 10)) (* (* re re) 1/2) (* re re) (* im im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im (/ (log im) (log 10))) (/ (log im) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log im) (log 10)) (* (log 10) (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (/ (* (* re re) 1/2) (* im im)))

rewrite354.0ms (8.3%)

Memory

-62.0MiB live, 314.2MiB allocated; 148ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	441	5737
0	506	5312
1	1971	4721
0	9332	4413

Stop Event

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

Counts

191 → 697

Calls

Call 1

Inputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) #s(literal 1/2 binary64)) (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (fma.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) #s(literal 1/2 binary64)) (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(fma.f64 (.f64 (/.f64 (.f64 (/.f64 re im) re) im) #s(literal 1/2 binary64)) (log.f64 #s(literal 1/10 binary64)) (*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))
(.f64 (/.f64 (.f64 (/.f64 re im) re) im) #s(literal 1/2 binary64))
(/.f64 (*.f64 (/.f64 re im) re) im)
(*.f64 (/.f64 re im) re)
(/.f64 re im)
re
im
#s(literal 1/2 binary64)
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(*.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(neg.f64 (log.f64 im))
(log.f64 im)
(*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (*.f64 im im))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (*.f64 im im)))
(/.f64 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (*.f64 im im))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(.f64 (.f64 re re) #s(literal 1/2 binary64))
(*.f64 re re)
(*.f64 im im)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 im (.f64 im (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 im im))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 im (.f64 im (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 im im)))
(/.f64 (fma.f64 im (.f64 im (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 im im))
(fma.f64 im (.f64 im (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (/.f64 (.f64 (*.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))))
(*.f64 im (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64)))))
(/.f64 #s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 10 binary64)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (.f64 im im)) (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64)))))
(/.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (.f64 im im)) (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (*.f64 (log.f64 #s(literal 10 binary64)) (log.f64 #s(literal 1/10 binary64))))
(fma.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (.f64 im im)) (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im))))
(/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* -1 (/ (log im) (log 1/10)))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* -1 (/ (log im) (log 1/10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* -1 (* (log 10) (log im)))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* -1 (* (log 10) (log im))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))))))
#s(approx (* (/ (* (/ re im) re) im) 1/2) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (/ (* (/ re im) re) im) #s(hole binary64 (/ (pow re 2) (pow im 2))))
#s(approx (* (/ re im) re) #s(hole binary64 (/ (pow re 2) im)))
#s(approx (/ re im) #s(hole binary64 (/ re im)))
#s(approx re #s(hole binary64 re))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (/ (* (pow im 2) (log im)) (log 10))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10)))))
#s(approx (/ (* (* re re) 1/2) (log 10)) #s(hole binary64 (* 1/2 (/ (pow re 2) (log 10)))))
#s(approx (* (* re re) 1/2) #s(hole binary64 (* 1/2 (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (/ (* (pow im 2) (log im)) (log 10))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* (log 10) (log im))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2))) (* (log 10) (log im)))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* -1 (/ (log im) (log 1/10)))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* -1 (/ (log im) (log 1/10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* -1 (* (log 10) (log im)))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* -1 (* (log 10) (log im))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))))))
#s(approx (/ (* (* re re) 1/2) (* im im)) #s(hole binary64 (* 1/2 (/ (pow re 2) (pow im 2)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (log im) (* (pow re 2) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2)))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (* (log 10) (log im)) (pow re 2))) (* 1/2 (/ (log 1/10) (pow im 2)))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (log 10)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (log 10))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log 10)))))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (log 10)))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (log 10))) (/ (* (pow im 2) (log im)) (* (pow re 2) (log 10)))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ 1 (* (pow im 2) (log 10)))) (/ (log im) (* (pow re 2) (log 10)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2)))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* (pow re 2) (+ (* 1/2 (/ (log 10) (pow im 2))) (/ (* (log 10) (log im)) (pow re 2))))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (log im) (* (pow re 2) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2)))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* (pow re 2) (+ (* -1 (/ (* (log 10) (log im)) (pow re 2))) (* 1/2 (/ (log 1/10) (pow im 2)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (/ (+ (* -1 (/ (* (pow im 2) (log im)) (log 1/10))) (* 1/2 (/ (pow re 2) (log 10)))) (pow im 2))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (/ (+ (* -1 (* (pow im 2) (* (log 10) (log im)))) (* 1/2 (* (pow re 2) (log 1/10)))) (pow im 2))))
#s(approx im #s(hole binary64 im))
#s(approx (* (log 10) (neg (log im))) #s(hole binary64 (* -1 (* (log 10) (log im)))))
#s(approx (neg (log im)) #s(hole binary64 (* -1 (log im))))
#s(approx (log im) #s(hole binary64 (log im)))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (* im (/ (log im) (log 10))) #s(hole binary64 (/ (* im (log im)) (log 10))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (/ (+ (* 1/2 (/ (pow re 2) (log 10))) (/ (* (pow im 2) (log im)) (log 10))) (pow im 2))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (/ (+ (* 1/2 (* (pow re 2) (log 10))) (* (pow im 2) (* (log 10) (log im)))) (pow im 2))))
#s(approx (* (log im) (log 10)) #s(hole binary64 (* (log 10) (log im))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (/ (+ (* -1 (/ (* (pow im 2) (log im)) (log 1/10))) (* 1/2 (/ (pow re 2) (log 10)))) (pow im 2))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (/ (+ (* -1 (* (pow im 2) (* (log 10) (log im)))) (* 1/2 (* (pow re 2) (log 1/10)))) (pow im 2))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* (log 10) (log (/ 1 im)))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))) (* (log 10) (log (/ 1 im))))))
#s(approx (* (log 10) (neg (log im))) #s(hole binary64 (* (log 10) (log (/ 1 im)))))
#s(approx (neg (log im)) #s(hole binary64 (log (/ 1 im))))
#s(approx (log im) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* -1 (/ (* (pow im 2) (log (/ 1 im))) (log 10)))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (* -1 (/ (* (pow im 2) (log (/ 1 im))) (log 10)))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (* im (/ (log im) (log 10))) #s(hole binary64 (* -1 (/ (* im (log (/ 1 im))) (log 10)))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* -1 (* (log 10) (log (/ 1 im))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (+ (* -1 (* (log 10) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2))))))
#s(approx (* (log im) (log 10)) #s(hole binary64 (* -1 (* (log 10) (log (/ 1 im))))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* (log 10) (log (/ 1 im)))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))) (* (log 10) (log (/ 1 im))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole 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)))))))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))))
#s(approx (/ (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (+ (* (* (/ (* (/ re im) re) im) 1/2) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))))))
#s(approx (* (log 10) (neg (log im))) #s(hole binary64 (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (neg (log im)) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (log im) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 im))))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10)))))
#s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10)))))
#s(approx (/ (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10))))))
#s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10)))))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10)))))
#s(approx (/ (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (* im im)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log 10))) (/ (log -1) (log 10))))))
#s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) #s(hole binary64 (* (pow im 2) (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10)))))))
#s(approx (* im (/ (log im) (log 10))) #s(hole binary64 (/ (* im (+ (log -1) (* -1 (log (/ -1 im))))) (log 10))))
#s(approx (/ (log im) (log 10)) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 10))))
#s(approx (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (* (log 10) (log 10))) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log -1) (log 10))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) #s(hole binary64 (+ (* 1/2 (/ (* (pow re 2) (log 10)) (pow im 2))) (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (* (log im) (log 10)) #s(hole binary64 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10)))))
#s(approx (/ (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) (* (log 10) (log 1/10))) #s(hole binary64 (+ (* -1 (/ (+ (log -1) (* -1 (log (/ -1 im)))) (log 1/10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im))))))))
#s(approx (+ (* (/ (* (* re re) 1/2) (* im im)) (log 1/10)) (* (log 10) (neg (log im)))) #s(hole binary64 (+ (* -1 (* (log 10) (+ (log -1) (* -1 (log (/ -1 im)))))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (pow im 2))))))

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

eval105.0ms (2.4%)

Memory: 29.1MiB live, 256.3MiB allocated; 53ms collecting garbage
Compiler: Compiled 32 651 to 2 659 computations (91.9% saved)

prune103.0ms (2.4%)

Memory

-36.2MiB live, 104.1MiB allocated; 33ms collecting garbage

Pruning

21 alts after pruning (14 fresh and 7 done)

	Pruned	Kept	Total
New	658	12	670
Fresh	6	2	8
Picked	4	1	5
Done	0	6	6
Total	668	21	689

Accuracy

100.0%

Counts

689 → 21

Alt Table

Click to see full alt table

Status	Accuracy	Program
	45.4%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	45.6%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
✓	98.9%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
✓	98.1%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.2%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	98.4%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
✓	98.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
	98.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (/.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) (.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))) (log.f64 #s(literal 10 binary64))) (log.f64 #s(literal 1/10 binary64))))
	98.3%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (/.f64 #s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (log.f64 #s(literal 10 binary64))) (log.f64 #s(literal 10 binary64))))
	98.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (neg.f64 (/.f64 #s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (log.f64 #s(literal 10 binary64)))) (log.f64 #s(literal 1/10 binary64))))
	97.8%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (*.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64))))
	98.6%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log 10) (log im))) (.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (.f64 (neg.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 #s(literal 10 binary64)))))
	98.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (fma.f64 (/.f64 (/.f64 (.f64 (log.f64 im) im) (log.f64 #s(literal 10 binary64))) im) (/.f64 im im) (.f64 (*.f64 (/.f64 re im) re) (/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) im)))))
	43.3%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 (/.f64 (.f64 (log.f64 im) im) (log.f64 #s(literal 10 binary64))) im (.f64 (.f64 re re) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im))))
	43.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (fma.f64 im (/.f64 (neg.f64 (.f64 (log.f64 im) im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 im im))))
	43.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (/.f64 (+.f64 (neg.f64 (.f64 (.f64 im im) (log.f64 im))) (neg.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (log.f64 #s(literal 1/10 binary64))) (*.f64 im im))))
	3.3%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (/.f64 #s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (.f64 (.f64 re re) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))) im) im)))
✓	2.7%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (*.f64 im im))))
	2.7%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (.f64 (.f64 re re) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))) (*.f64 im im))))
	43.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 #s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (/.f64 (.f64 (.f64 im im) (log.f64 im)) (log.f64 #s(literal 10 binary64)))) (*.f64 im im))))
	43.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 #s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (neg.f64 (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))) (*.f64 im im))))

Compiler

Compiled 2 512 to 799 computations (68.2% saved)

regimes93.0ms (2.2%)

Memory

34.4MiB live, 82.3MiB allocated; 3ms collecting garbage

Counts

39 → 1

Calls

Call 1

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

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

Calls

8 calls:

24.0ms	(*.f64 re re)
10.0ms	im
10.0ms	re
10.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
9.0ms	(+.f64 (.f64 re re) (.f64 im im))

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes35.0ms (0.8%)

Memory

14.2MiB live, 56.3MiB allocated; 9ms collecting garbage

Counts

12 → 1

Calls

Call 1

Inputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (.f64 (.f64 re re) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))) (*.f64 im im))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (*.f64 im im))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (/.f64 #s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (.f64 (.f64 re re) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))) im) im)))
(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (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)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 #s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (/.f64 (.f64 (.f64 im im) (log.f64 im)) (log.f64 #s(literal 10 binary64)))) (*.f64 im im))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (*.f64 im im))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 #s(approx (+ (* im (* im (/ (log im) (log 10)))) (/ (* (* re re) 1/2) (log 10))) (neg.f64 (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))) (*.f64 im im))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (/.f64 (/.f64 (+.f64 (neg.f64 (.f64 (.f64 im im) (log.f64 im))) (neg.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (log.f64 #s(literal 1/10 binary64))) (*.f64 im im))))

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes17.0ms (0.4%)

Memory

-11.3MiB live, 32.2MiB allocated; 5ms collecting garbage

Counts

3 → 1

Calls

Call 1

Inputs

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

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

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

Outputs

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes41.0ms (0.9%)

Memory

-26.8MiB live, 30.9MiB allocated; 45ms collecting garbage

Counts

2 → 1

Calls

Call 1

Inputs

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

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

Outputs

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

Calls

8 calls:

31.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
1.0ms	im
1.0ms	re
1.0ms	(+.f64 (.f64 re re) (.f64 im im))
1.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes9.0ms (0.2%)

Memory

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

Accuracy

Total 0.0b remaining (0%)

Threshold costs 0b (0%)

Counts

1 → 1

Calls

Call 1

Inputs

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

Outputs

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

simplify93.0ms (2.2%)

Memory

-8.2MiB live, 84.1MiB allocated; 16ms collecting garbage

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	56	210
1	99	192
2	275	192
3	787	192
4	1919	192
5	4198	192
6	5584	192
7	6590	192
8	7129	192
9	7566	192
10	7921	192

Stop Event

1×	node limit

Calls

Call 1

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

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

derivations240.0ms (5.6%)

Memory

-18.6MiB live, 174.4MiB allocated; 21ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 210 to 53 computations (74.8% saved)

preprocess46.0ms (1.1%)

Memory

16.9MiB live, 59.5MiB allocated; 7ms collecting garbage

Remove

(sort re im)

(abs im)

(abs re)

Compiler

Compiled 570 to 252 computations (55.8% saved)

end0.0ms (0%)

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

Iter	Nodes	Cost
0	28	74
1	60	74
2	110	74
3	135	74
4	173	74
0	10	12
0	17	12
1	28	12
2	67	12
3	124	12
4	161	12
0	161	7

Iter	Nodes	Cost
0	28	74
1	60	74
2	110	74
3	135	74
4	173	74
0	10	12
0	17	12
1	28	12
2	67	12
3	124	12
4	161	12
0	161	7

start0.0ms (0%)

analyze65.0ms (1.5%)

sample1.1s (26.2%)

explain311.0ms (7.3%)

preprocess20.0ms (0.5%)

eval0.0ms (0%)

prune0.0ms (0%)

series15.0ms (0.4%)

rewrite272.0ms (6.3%)

eval30.0ms (0.7%)

prune6.0ms (0.1%)

series148.0ms (3.5%)

rewrite226.0ms (5.3%)

eval79.0ms (1.8%)

prune20.0ms (0.5%)

series184.0ms (4.3%)

rewrite280.0ms (6.5%)

eval128.0ms (3%)

prune61.0ms (1.4%)

series180.0ms (4.2%)

rewrite354.0ms (8.3%)

eval105.0ms (2.4%)

prune103.0ms (2.4%)

regimes93.0ms (2.2%)

regimes35.0ms (0.8%)

regimes17.0ms (0.4%)

regimes41.0ms (0.9%)

regimes9.0ms (0.2%)

simplify93.0ms (2.2%)

derivations240.0ms (5.6%)

preprocess46.0ms (1.1%)

end0.0ms (0%)

Profiling

Iter	Nodes	Cost
0	28	74
1	60	74
2	110	74
3	135	74
4	173	74
0	10	12
0	17	12
1	28	12
2	67	12
3	124	12
4	161	12
0	161	7