Metrics for math.log10 on complex, real part

start0.0ms (0%)

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

analyze69.0ms (1.3%)

Memory

-1.3MiB live, 91.2MiB allocated; 14ms 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 (20%)

Memory

35.8MiB live, 1 134.6MiB allocated; 311ms collecting garbage

Samples

785.0ms

8 256×

valid

Precisions

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

ival-hypot: 227.0ms (44.8% of total)

ival-log: 204.0ms (40.3% of total)

ival-div: 65.0ms (12.8% of total)

exact: 6.0ms (1.2% of total)

adjust: 3.0ms (0.6% of total)

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

Bogosity

explain187.0ms (3.5%)

Memory

-1.8MiB live, 238.9MiB allocated; 25ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
126	-	3	(3.13075361169131e-160 -8.715899332321842e-263)	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
0	-	0	-	`(log.f64 #s(literal 10 binary64))`
0	-	0	-	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
0	-	0	-	`(*.f64 re re)`
0	-	0	-	`im`
0	-	0	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	0	-	`re`
0	-	0	-	`(*.f64 im im)`
0	-	0	-	`#s(literal 10 binary64)`
0	-	0	-	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`

Explanations

Click to see full explanations table

Operator	Subexpression	Explanation	Count
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	oflow-rescue	113	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	113
↳	`(*.f64 re re)`	overflow	59
↳	`(*.f64 im im)`	overflow	73
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	10	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	10
↳	`(*.f64 re re)`	underflow	69
↳	`(*.f64 im im)`	underflow	46

Confusion

	Predicted +	Predicted -
+	123	3
-	0	130

Precision

1.0

Recall

0.9761904761904762

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	123	0	3
-	0	0	130

Precision?

1.0

Recall?

0.9761904761904762

Freqs

test

number	freq
0	133
1	123

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

64.0ms

512×

valid

Compiler

Compiled 110 to 34 computations (69.1% saved)

Precisions

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

ival-hypot: 18.0ms (39.6% of total)

ival-log: 14.0ms (30.8% of total)

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

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

ival-add: 2.0ms (4.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)

preprocess32.0ms (0.6%)

Memory

-16.3MiB live, 29.1MiB 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.0MiB live, 0.0MiB allocated; 0ms collecting garbage
Compiler: Compiled 0 to 2 computations (-∞% saved)

prune0.0ms (0%)

Memory

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

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	52.4%	(/.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)

series21.0ms (0.4%)

Memory

-27.7MiB live, 22.7MiB allocated; 8ms 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
6.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)
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)

rewrite251.0ms (4.7%)

Memory

45.4MiB live, 264.4MiB allocated; 80ms 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))))

eval28.0ms (0.5%)

Memory: 10.3MiB live, 54.6MiB allocated; 9ms collecting garbage
Compiler: Compiled 4 158 to 936 computations (77.5% saved)

prune824.0ms (15.4%)

Memory

-197.9MiB live, 132.4MiB allocated; 1.2s 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
▶	52.4%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
▶	99.0%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
▶	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶	98.2%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶	98.7%	#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)

series190.0ms (3.5%)

Memory

20.4MiB live, 208.1MiB allocated; 17ms collecting garbage

Counts

29 → 261

Calls

Call 1

Inputs
(/.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)
im
re
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/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)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(.f64 #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 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (hypot.f64 re im))
(hypot.f64 re im)
#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 (/ (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 re #s(hole binary64 re))
#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 (/ (* 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 (+ (* (/ 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 (/ (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 (/ (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 (+ (* (/ 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 (/ (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 (* -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 (* -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 im #s(hole binary64 im))
#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 (/ (* 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 (+ (* (/ 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 (/ (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 (/ (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 (+ (* (/ 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 (/ (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 (/ (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 (+ (* (/ 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
92.0ms	im	@	-inf	((/ (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))) im re (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (log 10) 10 (/ (* 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) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (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))
38.0ms	im	@	0	((/ (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))) im re (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (log 10) 10 (/ (* 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) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (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))
22.0ms	im	@	inf	((/ (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))) im re (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (log 10) 10 (/ (* 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) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (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	((/ (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))) im re (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (log 10) 10 (/ (* 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) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (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	((/ (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))) im re (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (log 10) 10 (/ (* 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) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (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))

rewrite258.0ms (4.8%)

Memory

-1.5MiB live, 177.8MiB allocated; 29ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	808	7811
0	844	6885
1	4290	6697
0	10174	6410

Stop Event

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

Counts

290 → 435

Calls

Call 1

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

eval48.0ms (0.9%)

Memory: 2.3MiB live, 47.3MiB allocated; 5ms collecting garbage
Compiler: Compiled 8 857 to 1 289 computations (85.4% saved)

prune16.0ms (0.3%)

Memory

-8.5MiB live, 36.4MiB allocated; 6ms collecting garbage

Pruning

10 alts after pruning (7 fresh and 3 done)

	Pruned	Kept	Total
New	313	7	320
Fresh	0	0	0
Picked	2	3	5
Done	0	0	0
Total	315	10	325

Accuracy

100.0%

Counts

325 → 10

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	52.4%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
▶	98.3%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	98.2%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶	87.6%	#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 re) (.f64 im im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
	98.6%	#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.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 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.0%	#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)))))
▶	50.8%	#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))))
▶	48.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 (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 613 to 384 computations (37.4% saved)

series163.0ms (3%)

Memory

34.5MiB live, 326.2MiB allocated; 61ms collecting garbage

Counts

44 → 217

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

Calls

6 calls:

Time	Variable		Point	Expression
33.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 (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (/ (* re re) (* im im))) (/ (log im) (log 10))) (/ 1/2 (log 10)) (/ (* re re) (* im im)) (* re re) (* im im) (/ (log im) (log 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))) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* (* re re) (log 10)))) (* re re)) (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* (* re re) (log 10)))) (/ (pow im -2) (log 10)) (pow im -2) -2 (/ (log im) (* (* re re) (log 10))) (* (* re re) (log 10)))
33.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 (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (/ (* re re) (* im im))) (/ (log im) (log 10))) (/ 1/2 (log 10)) (/ (* re re) (* im im)) (* re re) (* im im) (/ (log im) (log 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))) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* (* re re) (log 10)))) (* re re)) (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* (* re re) (log 10)))) (/ (pow im -2) (log 10)) (pow im -2) -2 (/ (log im) (* (* re re) (log 10))) (* (* re re) (log 10)))
25.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 (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (/ (* re re) (* im im))) (/ (log im) (log 10))) (/ 1/2 (log 10)) (/ (* re re) (* im im)) (* re re) (* im im) (/ (log im) (log 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))) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* (* re re) (log 10)))) (* re re)) (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* (* re re) (log 10)))) (/ (pow im -2) (log 10)) (pow im -2) -2 (/ (log im) (* (* re re) (log 10))) (* (* re re) (log 10)))
23.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 (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (/ (* re re) (* im im))) (/ (log im) (log 10))) (/ 1/2 (log 10)) (/ (* re re) (* im im)) (* re re) (* im im) (/ (log im) (log 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))) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* (* re re) (log 10)))) (* re re)) (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* (* re re) (log 10)))) (/ (pow im -2) (log 10)) (pow im -2) -2 (/ (log im) (* (* re re) (log 10))) (* (* re re) (log 10)))
23.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 (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (/ (* re re) (* im im))) (/ (log im) (log 10))) (/ 1/2 (log 10)) (/ (* re re) (* im im)) (* re re) (* im im) (/ (log im) (log 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))) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* (* re re) (log 10)))) (* re re)) (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* (* re re) (log 10)))) (/ (pow im -2) (log 10)) (pow im -2) -2 (/ (log im) (* (* re re) (log 10))) (* (* re re) (log 10)))

rewrite231.0ms (4.3%)

Memory

5.1MiB live, 334.4MiB allocated; 46ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	758	7739
0	835	7248
1	4005	6917
0	9286	6139

Stop Event

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

Counts

261 → 531

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

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

eval111.0ms (2.1%)

Memory: 10.6MiB live, 189.5MiB allocated; 89ms collecting garbage
Compiler: Compiled 27 394 to 2 537 computations (90.7% saved)

prune30.0ms (0.6%)

Memory

-27.0MiB live, 67.5MiB allocated; 11ms collecting garbage

Pruning

22 alts after pruning (17 fresh and 5 done)

	Pruned	Kept	Total
New	574	17	591
Fresh	2	0	2
Picked	3	2	5
Done	0	3	3
Total	579	22	601

Accuracy

100.0%

Counts

601 → 22

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	52.4%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
✓	98.3%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	98.2%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
✓	87.6%	#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 re) (.f64 im im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
▶	98.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 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)))))
	91.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (/.f64 (/.f64 (.f64 re re) im) 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)))))
	50.7%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 re re)) (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im im) (log.f64 im))) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))))
▶	50.6%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 re re)) (log.f64 #s(literal 1/10 binary64)) (.f64 (neg.f64 (log.f64 im)) (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 im im))))
	95.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (.f64 re (/.f64 re (.f64 im 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)))))
	50.6%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.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 (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))) (log.f64 #s(literal 10 binary64)))))
	48.3%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (/ (* re re) (* im 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 (neg.f64 (log.f64 im)) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re)))) (.f64 re re))))
▶	50.6%	#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))))
	52.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 (/.f64 (fma.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (*.f64 im im))) im) im)))
▶	3.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 #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))))
	20.6%	#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 (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))) (*.f64 im im))))
	50.6%	#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 (log.f64 im) (log.f64 #s(literal 10 binary64))) (.f64 im im))) (*.f64 im im))))
	50.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))) (neg.f64 (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))))) (*.f64 im im))))
	48.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 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (/.f64 (log.f64 im) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) (*.f64 re re))))
▶	48.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 (pow.f64 im #s(literal -2 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (.f64 re (.f64 re (log.f64 #s(literal 10 binary64)))))) (.f64 re re))))
	49.6%	#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 (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))))) re) re)))
	48.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 (+ ( (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* (* re re) (log 10)))) (/.f64 (log.f64 im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (*.f64 re re))))

Compiler

Compiled 1 826 to 1 093 computations (40.1% saved)

series308.0ms (5.7%)

Memory

-10.9MiB live, 337.5MiB allocated; 111ms collecting garbage

Counts

50 → 156

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

Calls

6 calls:

Time	Variable		Point	Expression
77.0ms	re	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log im) (log 10))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log im) (log 10))) (* (pow (/ re im) 2) 1/2) (pow (/ re im) 2) (/ re im) re im 2 1/2 (log 10) 10 (* (log im) (log 10)) (log im) (* (log 10) (log 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)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* re (* re (log 10))))) (* re re)) (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* re (* re (log 10))))) (/ (pow im -2) (log 10)) (pow im -2) -2 (/ (log im) (* re (* re (log 10)))) (* re (* re (log 10))) (* re (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (* (log 1/10) (* im im))) (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (* (/ -1/2 (log 1/10)) (* re re)) (/ -1/2 (log 1/10)) -1/2 (log 1/10) 1/10 (* (neg (log im)) (* im im)) (neg (log im)) (* (log 1/10) (* im im)))
74.0ms	re	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log im) (log 10))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log im) (log 10))) (* (pow (/ re im) 2) 1/2) (pow (/ re im) 2) (/ re im) re im 2 1/2 (log 10) 10 (* (log im) (log 10)) (log im) (* (log 10) (log 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)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* re (* re (log 10))))) (* re re)) (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* re (* re (log 10))))) (/ (pow im -2) (log 10)) (pow im -2) -2 (/ (log im) (* re (* re (log 10)))) (* re (* re (log 10))) (* re (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (* (log 1/10) (* im im))) (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (* (/ -1/2 (log 1/10)) (* re re)) (/ -1/2 (log 1/10)) -1/2 (log 1/10) 1/10 (* (neg (log im)) (* im im)) (neg (log im)) (* (log 1/10) (* im im)))
50.0ms	im	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log im) (log 10))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log im) (log 10))) (* (pow (/ re im) 2) 1/2) (pow (/ re im) 2) (/ re im) re im 2 1/2 (log 10) 10 (* (log im) (log 10)) (log im) (* (log 10) (log 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)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* re (* re (log 10))))) (* re re)) (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* re (* re (log 10))))) (/ (pow im -2) (log 10)) (pow im -2) -2 (/ (log im) (* re (* re (log 10)))) (* re (* re (log 10))) (* re (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (* (log 1/10) (* im im))) (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (* (/ -1/2 (log 1/10)) (* re re)) (/ -1/2 (log 1/10)) -1/2 (log 1/10) 1/10 (* (neg (log im)) (* im im)) (neg (log im)) (* (log 1/10) (* im im)))
41.0ms	im	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log im) (log 10))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log im) (log 10))) (* (pow (/ re im) 2) 1/2) (pow (/ re im) 2) (/ re im) re im 2 1/2 (log 10) 10 (* (log im) (log 10)) (log im) (* (log 10) (log 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)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* re (* re (log 10))))) (* re re)) (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* re (* re (log 10))))) (/ (pow im -2) (log 10)) (pow im -2) -2 (/ (log im) (* re (* re (log 10)))) (* re (* re (log 10))) (* re (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (* (log 1/10) (* im im))) (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (* (/ -1/2 (log 1/10)) (* re re)) (/ -1/2 (log 1/10)) -1/2 (log 1/10) 1/10 (* (neg (log im)) (* im im)) (neg (log im)) (* (log 1/10) (* im im)))
31.0ms	im	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log im) (log 10))) (* (log 10) (log 10))) (+ (* (* (pow (/ re im) 2) 1/2) (log 10)) (* (log im) (log 10))) (* (pow (/ re im) 2) 1/2) (pow (/ re im) 2) (/ re im) re im 2 1/2 (log 10) 10 (* (log im) (log 10)) (log im) (* (log 10) (log 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)) (+ (* (/ 1/2 (log 10)) (* (/ re im) (/ re im))) (/ (log im) (log 10))) (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* re (* re (log 10))))) (* re re)) (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* re (* re (log 10))))) (/ (pow im -2) (log 10)) (pow im -2) -2 (/ (log im) (* re (* re (log 10)))) (* re (* re (log 10))) (* re (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (* (log 1/10) (* im im))) (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (* (/ -1/2 (log 1/10)) (* re re)) (/ -1/2 (log 1/10)) -1/2 (log 1/10) 1/10 (* (neg (log im)) (* im im)) (neg (log im)) (* (log 1/10) (* im im)))

rewrite243.0ms (4.5%)

Memory

13.7MiB live, 240.5MiB allocated; 31ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	478	5849
0	557	5406
1	2165	5026
0	9653	4703

Stop Event

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

Counts

206 → 753

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

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

eval153.0ms (2.9%)

Memory: 23.1MiB live, 214.5MiB allocated; 25ms collecting garbage
Compiler: Compiled 47 201 to 3 890 computations (91.8% saved)

prune102.0ms (1.9%)

Memory

-16.6MiB live, 174.8MiB allocated; 53ms collecting garbage

Pruning

27 alts after pruning (23 fresh and 4 done)

	Pruned	Kept	Total
New	883	19	902
Fresh	8	4	12
Picked	5	0	5
Done	1	4	5
Total	897	27	924

Accuracy

100.0%

Counts

924 → 27

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	52.4%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
✓	98.3%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	98.2%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
	91.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 (neg.f64 (log.f64 im)) im) (.f64 (log.f64 #s(literal 1/10 binary64)) im)) (/.f64 im im) (.f64 (/.f64 (.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) re) (.f64 (log.f64 #s(literal 1/10 binary64)) im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) im))))
	91.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (/.f64 (/.f64 (.f64 re re) im) 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.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 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)))))
	95.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (.f64 re (/.f64 re (.f64 im 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)))))
	50.5%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (fma.f64 (.f64 (neg.f64 (log.f64 im)) im) im (.f64 (.f64 re re) #s(literal -1/2 binary64)))) (.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 im im))))
	50.6%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (.f64 (fma.f64 (pow.f64 (/.f64 re im) #s(literal 2 binary64)) #s(literal -1/2 binary64) (neg.f64 (log.f64 im))) (.f64 im im))) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 im im))))
	20.5%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (.f64 (-.f64 (.f64 (/.f64 (.f64 (neg.f64 (log.f64 im)) im) re) (/.f64 im re)) #s(literal 1/2 binary64)) (.f64 re re))) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 im im))))
	50.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (.f64 (.f64 (neg.f64 (log.f64 im)) im) im)) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 im im))))
	3.0%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (.f64 (.f64 re re) #s(literal -1/2 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 im im))))
	48.3%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (/ 1/2 (log 10)) (/ (* re re) (* im 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 (neg.f64 (log.f64 im)) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re)))) (.f64 re re))))
	98.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))) (fma.f64 (/.f64 (/.f64 (.f64 (log.f64 im) im) (log.f64 #s(literal 10 binary64))) im) (/.f64 im im) (.f64 (/.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) im) (/.f64 re im)))))
	52.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))) (fma.f64 (/.f64 (.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 1/10 binary64)))) im) (/.f64 #s(literal -1 binary64) im) (.f64 (/.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) im) (/.f64 re im)))))
	50.6%	#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 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) re)) (.f64 im im))))
	50.6%	#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))))
	50.6%	#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 (neg.f64 (log.f64 im)) im) im (.f64 (.f64 re re) #s(literal -1/2 binary64))) (log.f64 #s(literal 1/10 binary64))) (.f64 im im))))
	52.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 (/.f64 (/.f64 (fma.f64 (.f64 im im) (log.f64 im) (.f64 (*.f64 re re) #s(literal 1/2 binary64))) (log.f64 #s(literal 10 binary64))) im) im)))
	3.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 (/.f64 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) re)) im) im)))
	50.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 im im) (log.f64 im)) (log.f64 #s(literal 10 binary64)))) (*.f64 im im))))
	3.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 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))) (*.f64 im im))))
	3.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 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))) (*.f64 im im))))
	49.6%	#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 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (*.f64 re re))) (log.f64 #s(literal 10 binary64))) re) re)))
	48.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 (+ ( (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* (* re re) (log 10)))) (/.f64 (log.f64 im) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (*.f64 re re))))
	48.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 (+ ( (/ (pow im -2) (log 10)) 1/2) (/ (log im) (* re (* re (log 10))))) (/.f64 (/.f64 (log.f64 im) re) (.f64 (log.f64 #s(literal 10 binary64)) re))) (.f64 re re))))

Compiler

Compiled 3 541 to 1 114 computations (68.5% saved)

regimes251.0ms (4.7%)

Memory

19.8MiB live, 210.6MiB allocated; 19ms collecting garbage

Counts

49 → 1

Calls

Call 1

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

Calls

8 calls:

100.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
59.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
28.0ms	(*.f64 re re)
14.0ms	im
12.0ms	re

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes91.0ms (1.7%)

Memory

-37.7MiB live, 62.7MiB allocated; 11ms collecting garbage

Counts

20 → 1

Calls

Call 1

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

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

Calls

8 calls:

47.0ms	re
11.0ms	(*.f64 im im)
6.0ms	im
5.0ms	(+.f64 (.f64 re re) (.f64 im im))
5.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes44.0ms (0.8%)

Memory

21.0MiB live, 67.0MiB allocated; 3ms collecting garbage

Counts

19 → 1

Calls

Call 1

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

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes33.0ms (0.6%)

Memory

-8.8MiB live, 37.7MiB allocated; 4ms collecting garbage

Counts

6 → 1

Calls

Call 1

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

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes39.0ms (0.7%)

Memory

-6.9MiB live, 39.8MiB allocated; 3ms collecting garbage

Counts

5 → 1

Calls

Call 1

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes15.0ms (0.3%)

Memory

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

Counts

4 → 1

Calls

Call 1

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes35.0ms (0.6%)

Memory

-32.0MiB live, 20.3MiB allocated; 3ms 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)) (/.f64 #s(approx (+ (* (* (/ -1/2 (log 1/10)) (* re re)) (log 1/10)) (* (neg (log im)) (* im im))) (*.f64 (*.f64 re re) #s(literal -1/2 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 im im))))

Outputs

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

Calls

8 calls:

26.0ms	im
1.0ms	(*.f64 im im)
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	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

simplify72.0ms (1.3%)

Memory

4.1MiB live, 50.8MiB allocated; 6ms collecting garbage

Iterations

Useful iterations: 4 (0.0ms)

Iter	Nodes	Cost
0	66	214
1	132	202
2	389	202
3	1214	198
4	3066	196
5	5278	196
6	7154	196
7	7517	196

Stop Event

1×	node limit

Calls

Call 1

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

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

derivations390.0ms (7.3%)

Memory

-7.9MiB live, 322.1MiB allocated; 63ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 215 to 68 computations (68.4% saved)

preprocess53.0ms (1%)

Memory

24.0MiB live, 110.3MiB allocated; 19ms collecting garbage

Remove

(sort re im)

(abs im)

(abs re)

Compiler

Compiled 598 to 300 computations (49.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%)

analyze69.0ms (1.3%)

sample1.1s (20%)

explain187.0ms (3.5%)

preprocess32.0ms (0.6%)

eval0.0ms (0%)

prune0.0ms (0%)

series21.0ms (0.4%)

rewrite251.0ms (4.7%)

eval28.0ms (0.5%)

prune824.0ms (15.4%)

series190.0ms (3.5%)

rewrite258.0ms (4.8%)

eval48.0ms (0.9%)

prune16.0ms (0.3%)

series163.0ms (3%)

rewrite231.0ms (4.3%)

eval111.0ms (2.1%)

prune30.0ms (0.6%)

series308.0ms (5.7%)

rewrite243.0ms (4.5%)

eval153.0ms (2.9%)

prune102.0ms (1.9%)

regimes251.0ms (4.7%)

regimes91.0ms (1.7%)

regimes44.0ms (0.8%)

regimes33.0ms (0.6%)

regimes39.0ms (0.7%)

regimes15.0ms (0.3%)

regimes35.0ms (0.6%)

simplify72.0ms (1.3%)

derivations390.0ms (7.3%)

preprocess53.0ms (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