Metrics for math.log10 on complex, real part

start0.0ms (0%)

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

analyze125.0ms (2.9%)

Memory

-36.8MiB live, 112.2MiB allocated; 59ms 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.5s (35.4%)

Memory

-59.8MiB live, 2 032.3MiB allocated; 1.0s collecting garbage

Samples

877.0ms

8 256×

valid

Precisions

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

ival-hypot: 268.0ms (41.6% of total)

ival-log: 254.0ms (39.4% of total)

ival-div: 111.0ms (17.2% of total)

exact: 6.0ms (0.9% of total)

adjust: 3.0ms (0.5% of total)

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

Bogosity

explain169.0ms (3.9%)

Memory

-0.3MiB live, 341.5MiB allocated; 72ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Example	Subexpression
130	-	-	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
0	-	-	`(log.f64 #s(literal 10 binary64))`
0	-	-	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
0	-	-	`(*.f64 re re)`
0	-	-	`im`
0	-	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	-	`re`
0	-	-	`(*.f64 im im)`
0	-	-	`#s(literal 10 binary64)`
0	-	-	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`

Explanations

Click to see full explanations table

Operator	Subexpression	Explanation	Count
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	oflow-rescue	116	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	116
↳	`(*.f64 re re)`	overflow	67
↳	`(*.f64 im im)`	overflow	68
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	14	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	14
↳	`(*.f64 re re)`	underflow	60
↳	`(*.f64 im im)`	underflow	64

Confusion

	Predicted +	Predicted -
+	130	0
-	0	126

Precision

1.0

Recall

1.0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	130	0	0
-	0	0	126

Precision?

1.0

Recall?

1.0

Freqs

test

number	freq
0	126
1	130

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

51.0ms

512×

valid

Compiler

Compiled 110 to 34 computations (69.1% saved)

Precisions

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

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

ival-hypot: 9.0ms (27.2% of total)

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

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

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

adjust: 0.0ms (0% of total)

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

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

exact: 0.0ms (0% of total)

preprocess44.0ms (1%)

Memory

-17.8MiB live, 31.2MiB allocated; 7ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

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

Stop Event

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

Calls

Call 1

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

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

Symmetry

(abs re)

(abs im)

(sort re im)

Compiler

Compiled 12 to 10 computations (16.7% saved)

eval0.0ms (0%)

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

prune0.0ms (0%)

Memory

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

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	50.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)

series16.0ms (0.4%)

Memory

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

Counts

10 → 79

Calls

Call 1

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

Outputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx im #s(hole binary64 im))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (+ (* re re) (* im im)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))))

Calls

6 calls:

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

rewrite220.0ms (5.1%)

Memory

-18.5MiB live, 358.8MiB allocated; 48ms 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))))

eval32.0ms (0.7%)

Memory: -2.7MiB live, 88.5MiB allocated; 12ms collecting garbage
Compiler: Compiled 4 158 to 936 computations (77.5% saved)

prune6.0ms (0.1%)

Memory

26.9MiB live, 27.0MiB allocated; 0ms collecting garbage

Pruning

5 alts after pruning (5 fresh and 0 done)

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

Accuracy

99.7%

Counts

218 → 5

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	50.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.1%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶	97.5%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶	91.5%	(/.f64 #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))) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 130 to 106 computations (18.5% saved)

series116.0ms (2.7%)

Memory

-4.5MiB live, 281.2MiB allocated; 58ms collecting garbage

Counts

28 → 258

Calls

Call 1

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

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

Calls

6 calls:

Time	Variable		Point	Expression
31.0ms	im	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ 1/2 im) (/ (* re re) im) (log im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10)
25.0ms	im	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ 1/2 im) (/ (* re re) im) (log im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10)
24.0ms	im	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ 1/2 im) (/ (* re re) im) (log im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10)
13.0ms	re	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ 1/2 im) (/ (* re re) im) (log im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10)
10.0ms	re	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) re im (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ 1/2 im) (/ (* re re) im) (log im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (log 1/10) 1/10)

rewrite308.0ms (7.2%)

Memory

30.0MiB live, 335.2MiB allocated; 119ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	797	7654
0	829	6887
1	4249	6734
0	10007	6456

Stop Event

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

Counts

286 → 414

Calls

Call 1

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

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

eval43.0ms (1%)

Memory: -10.7MiB live, 93.6MiB allocated; 26ms collecting garbage
Compiler: Compiled 7 943 to 1 197 computations (84.9% saved)

prune18.0ms (0.4%)

Memory

10.2MiB live, 56.0MiB allocated; 7ms collecting garbage

Pruning

14 alts after pruning (10 fresh and 4 done)

	Pruned	Kept	Total
New	292	10	302
Fresh	0	0	0
Picked	1	4	5
Done	0	0	0
Total	293	14	307

Accuracy

99.7%

Counts

307 → 14

Alt Table

Click to see full alt table

Status	Accuracy	Program
	18.3%	(/.f64 (.f64 #s(literal 1/2 binary64) (-.f64 (log.f64 (+.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) (log.f64 (+.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 re im) #s(literal 2 binary64))))))) (log.f64 #s(literal 10 binary64)))
▶	50.4%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	50.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)))
	97.5%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
	98.3%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im)) (log.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
✓	99.1%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	97.5%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶	98.4%	(/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 re (/.f64 re im)) #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
	65.2%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/8 binary64) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))))) (log.f64 #s(literal 10 binary64)))
▶	98.3%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (-.f64 (pow.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) #s(literal 2 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
▶	48.2%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (.f64 im im) (log.f64 im) (.f64 (.f64 re re) #s(literal 1/2 binary64))) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
	47.5%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (.f64 re re))) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
▶	3.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))))) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 675 to 450 computations (33.3% saved)

series127.0ms (3%)

Memory

11.0MiB live, 162.6MiB allocated; 77ms collecting garbage

Counts

40 → 271

Calls

Call 1

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

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

Calls

6 calls:

Time	Variable		Point	Expression
63.0ms	im	@	0	((/ (log (sqrt (+ (* im im) (* re re)))) (log 10)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (neg (log 1/10)) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) (* im im)) (+ (* (* im im) (log im)) (* (* re re) 1/2)) (* im im) (log im) (* (* re re) 1/2) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (pow (* (/ 1/2 im) (* re (/ re im))) 2) 2 (pow (log im) 2) (- (* (/ 1/2 im) (* re (/ re im))) (log im)))
14.0ms	re	@	0	((/ (log (sqrt (+ (* im im) (* re re)))) (log 10)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (neg (log 1/10)) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) (* im im)) (+ (* (* im im) (log im)) (* (* re re) 1/2)) (* im im) (log im) (* (* re re) 1/2) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (pow (* (/ 1/2 im) (* re (/ re im))) 2) 2 (pow (log im) 2) (- (* (/ 1/2 im) (* re (/ re im))) (log im)))
12.0ms	im	@	-inf	((/ (log (sqrt (+ (* im im) (* re re)))) (log 10)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (neg (log 1/10)) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) (* im im)) (+ (* (* im im) (log im)) (* (* re re) 1/2)) (* im im) (log im) (* (* re re) 1/2) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (pow (* (/ 1/2 im) (* re (/ re im))) 2) 2 (pow (log im) 2) (- (* (/ 1/2 im) (* re (/ re im))) (log im)))
12.0ms	im	@	inf	((/ (log (sqrt (+ (* im im) (* re re)))) (log 10)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (neg (log 1/10)) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) (* im im)) (+ (* (* im im) (log im)) (* (* re re) 1/2)) (* im im) (log im) (* (* re re) 1/2) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (pow (* (/ 1/2 im) (* re (/ re im))) 2) 2 (pow (log im) 2) (- (* (/ 1/2 im) (* re (/ re im))) (log im)))
8.0ms	re	@	inf	((/ (log (sqrt (+ (* im im) (* re re)))) (log 10)) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re) (neg (log 1/10)) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) (* im im)) (+ (* (* im im) (log im)) (* (* re re) 1/2)) (* im im) (log im) (* (* re re) 1/2) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (pow (* (/ 1/2 im) (* re (/ re im))) 2) 2 (pow (log im) 2) (- (* (/ 1/2 im) (* re (/ re im))) (log im)))

rewrite216.0ms (5%)

Memory

-37.6MiB live, 386.3MiB allocated; 43ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	817	8938
0	873	8113
1	4262	8032
0	9799	7039

Stop Event

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

Counts

311 → 505

Calls

Call 1

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

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

eval80.0ms (1.9%)

Memory: 30.3MiB live, 259.9MiB allocated; 29ms collecting garbage
Compiler: Compiled 22 471 to 2 488 computations (88.9% saved)

prune56.0ms (1.3%)

Memory

16.9MiB live, 123.2MiB allocated; 30ms collecting garbage

Pruning

32 alts after pruning (25 fresh and 7 done)

	Pruned	Kept	Total
New	558	23	581
Fresh	3	2	5
Picked	2	3	5
Done	0	4	4
Total	563	32	595

Accuracy

99.9%

Counts

595 → 32

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	50.4%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	50.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)))
	98.3%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im)))) (log.f64 #s(literal 1/10 binary64)))
	97.5%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
	98.3%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im)) (log.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
▶	3.6%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* im im) (* re re)))) #s(approx (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im))))) (log.f64 #s(literal 1/10 binary64)))
✓	99.1%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	97.5%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
✓	98.4%	(/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 re (/.f64 re im)) #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
	86.0%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (/.f64 (-.f64 (pow.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im)) #s(literal 4 binary64)) (pow.f64 (log.f64 im) #s(literal 4 binary64))) (fma.f64 (pow.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 2 binary64)) #s(literal 1/4 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
	65.2%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (-.f64 (pow.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) #s(literal 2 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (-.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/8 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (fma.f64 (pow.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 2 binary64)) #s(literal 1/4 binary64) (fma.f64 (log.f64 im) (log.f64 im) (.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im)) (log.f64 im))))))) (log.f64 #s(literal 10 binary64)))
▶	98.3%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (-.f64 (pow.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) #s(literal 2 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1 binary64)))))) (log.f64 #s(literal 10 binary64)))
	98.2%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (-.f64 (pow.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) #s(literal 2 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) (log.f64 im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
	73.5%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (-.f64 (pow.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) #s(literal 2 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) (exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 1 binary64)))))) (log.f64 #s(literal 10 binary64)))
	72.9%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (-.f64 (pow.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) #s(literal 2 binary64)) (exp.f64 (.f64 (log.f64 (log.f64 im)) #s(literal 2 binary64)))) (-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
▶	98.3%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
	47.5%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (.f64 (fma.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (.f64 re re))) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
	3.6%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im)))) (log.f64 #s(literal 10 binary64)))
	48.1%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (pow.f64 (pow.f64 im #s(literal -1 binary64)) #s(literal -2 binary64)) (log.f64 im) (.f64 (.f64 re re) #s(literal 1/2 binary64))) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
	26.1%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (.f64 im im) (.f64 (.f64 im im) (.f64 (*.f64 im im) (log.f64 im)))) (pow.f64 im #s(literal 4 binary64))))) (log.f64 #s(literal 10 binary64)))
	48.2%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (.f64 im im) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1 binary64))) (.f64 (.f64 re re) #s(literal 1/2 binary64))) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
	48.1%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (.f64 im im) (log.f64 im) (.f64 (*.f64 re re) #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 im #s(literal -1 binary64)) #s(literal 2 binary64)))))) (log.f64 #s(literal 10 binary64)))
	48.2%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 im (.f64 im (log.f64 im)) (.f64 (.f64 re re) #s(literal 1/2 binary64))) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
▶	49.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (/.f64 (fma.f64 (.f64 im im) (log.f64 im) (.f64 (*.f64 re re) #s(literal 1/2 binary64))) im) im))) (log.f64 #s(literal 10 binary64)))
	3.5%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) im) im))) (log.f64 #s(literal 10 binary64)))
	3.5%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re)) im))) (log.f64 #s(literal 10 binary64)))
▶	3.0%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
	47.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 #s(approx (+ (* (* im im) (log im)) (* (* re re) 1/2)) (.f64 (.f64 im im) (log.f64 im))) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
	3.5%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im)))) (log.f64 #s(literal 10 binary64)))
	3.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	3.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))))) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 2 254 to 1 407 computations (37.6% saved)

series72.0ms (1.7%)

Memory

-39.5MiB live, 147.8MiB allocated; 16ms collecting garbage

Counts

49 → 228

Calls

Call 1

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

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

Calls

6 calls:

Time	Variable		Point	Expression
16.0ms	im	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (/ 1 (pow (log im) -1)))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (pow (* (/ 1/2 im) (* re (/ re im))) 2) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) 1/2 im (* re (/ re im)) re (/ re im) 2 (pow (log im) 2) (log im) (- (* (/ 1/2 im) (* re (/ re im))) (/ 1 (pow (log im) -1))) (/ 1 (pow (log im) -1)) 1 (pow (log im) -1) -1 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (* (* re re) 1/2) (* im im)) (* (* re re) 1/2) (* re re) (* im im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (* (* (/ 1/2 im) re) (/ re im)) (* (/ 1/2 im) re) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) im) im) (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) im) (+ (* (* im im) (log im)) (* (* re re) 1/2)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (neg (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im)))
12.0ms	im	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (/ 1 (pow (log im) -1)))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (pow (* (/ 1/2 im) (* re (/ re im))) 2) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) 1/2 im (* re (/ re im)) re (/ re im) 2 (pow (log im) 2) (log im) (- (* (/ 1/2 im) (* re (/ re im))) (/ 1 (pow (log im) -1))) (/ 1 (pow (log im) -1)) 1 (pow (log im) -1) -1 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (* (* re re) 1/2) (* im im)) (* (* re re) 1/2) (* re re) (* im im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (* (* (/ 1/2 im) re) (/ re im)) (* (/ 1/2 im) re) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) im) im) (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) im) (+ (* (* im im) (log im)) (* (* re re) 1/2)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (neg (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im)))
12.0ms	im	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (/ 1 (pow (log im) -1)))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (pow (* (/ 1/2 im) (* re (/ re im))) 2) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) 1/2 im (* re (/ re im)) re (/ re im) 2 (pow (log im) 2) (log im) (- (* (/ 1/2 im) (* re (/ re im))) (/ 1 (pow (log im) -1))) (/ 1 (pow (log im) -1)) 1 (pow (log im) -1) -1 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (* (* re re) 1/2) (* im im)) (* (* re re) 1/2) (* re re) (* im im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (* (* (/ 1/2 im) re) (/ re im)) (* (/ 1/2 im) re) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) im) im) (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) im) (+ (* (* im im) (log im)) (* (* re re) 1/2)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (neg (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im)))
8.0ms	re	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (/ 1 (pow (log im) -1)))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (pow (* (/ 1/2 im) (* re (/ re im))) 2) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) 1/2 im (* re (/ re im)) re (/ re im) 2 (pow (log im) 2) (log im) (- (* (/ 1/2 im) (* re (/ re im))) (/ 1 (pow (log im) -1))) (/ 1 (pow (log im) -1)) 1 (pow (log im) -1) -1 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (* (* re re) 1/2) (* im im)) (* (* re re) 1/2) (* re re) (* im im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (* (* (/ 1/2 im) re) (/ re im)) (* (/ 1/2 im) re) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) im) im) (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) im) (+ (* (* im im) (log im)) (* (* re re) 1/2)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (neg (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im)))
7.0ms	re	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (/ 1 (pow (log im) -1)))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (pow (* (/ 1/2 im) (* re (/ re im))) 2) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) 1/2 im (* re (/ re im)) re (/ re im) 2 (pow (log im) 2) (log im) (- (* (/ 1/2 im) (* re (/ re im))) (/ 1 (pow (log im) -1))) (/ 1 (pow (log im) -1)) 1 (pow (log im) -1) -1 (log 10) 10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (* (* re re) 1/2) (* im im)) (* (* re re) 1/2) (* re re) (* im im) (/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (* (* (/ 1/2 im) re) (/ re im)) (* (/ 1/2 im) re) (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/ (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) im) im) (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) im) (+ (* (* im im) (log im)) (* (* re re) 1/2)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (neg (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im)))

rewrite239.0ms (5.6%)

Memory

36.8MiB live, 262.4MiB allocated; 41ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	683	7965
0	749	7582
1	3359	6870
0	9102	6012

Stop Event

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

Counts

277 → 657

Calls

Call 1

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

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

eval135.0ms (3.2%)

Memory: 18.5MiB live, 212.5MiB allocated; 17ms collecting garbage
Compiler: Compiled 34 994 to 3 513 computations (90% saved)

prune147.0ms (3.4%)

Memory

-52.2MiB live, 102.9MiB allocated; 111ms collecting garbage

Pruning

38 alts after pruning (29 fresh and 9 done)

	Pruned	Kept	Total
New	737	16	753
Fresh	7	13	20
Picked	3	2	5
Done	0	7	7
Total	747	38	785

Accuracy

99.9%

Counts

785 → 38

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	50.4%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	50.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)))
	98.3%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 re (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) im)))) (log.f64 #s(literal 1/10 binary64)))
	97.5%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) im))) (log.f64 #s(literal 1/10 binary64)))
	98.3%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re (/.f64 re im)) (log.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
	98.2%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* im im) (* re re)))) (/.f64 #s(approx (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (-.f64 (.f64 (.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im)) (log.f64 im))))) (log.f64 #s(literal 1/10 binary64)))
	3.6%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* im im) (* re re)))) #s(approx (/ (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (- (* (/ 1/2 im) (* re (/ re im))) (log im))) (.f64 (/.f64 (.f64 #s(literal 1/2 binary64) re) im) (/.f64 re im))))) (log.f64 #s(literal 1/10 binary64)))
✓	99.1%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	97.5%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
✓	98.4%	(/.f64 (log.f64 #s(approx (sqrt (+ (* im im) (* re re))) (fma.f64 (*.f64 re (/.f64 re im)) #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
	91.4%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re)) (pow.f64 (log.f64 im) #s(literal -1 binary64)) (.f64 im #s(literal 1 binary64))) (.f64 im (pow.f64 (log.f64 im) #s(literal -1 binary64))))) (log.f64 #s(literal 10 binary64)))
	65.2%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (-.f64 (pow.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) #s(literal 2 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (-.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/8 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (fma.f64 (pow.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 2 binary64)) #s(literal 1/4 binary64) (fma.f64 (log.f64 im) (log.f64 im) (.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) (/.f64 re im)) (log.f64 im))))))) (log.f64 #s(literal 10 binary64)))
	91.4%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (-.f64 (pow.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) #s(literal 2 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (-.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re)) (pow.f64 (log.f64 im) #s(literal -1 binary64))) (.f64 im #s(literal 1 binary64))) (*.f64 im (pow.f64 (log.f64 im) #s(literal -1 binary64)))))) (log.f64 #s(literal 10 binary64)))
	98.2%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (-.f64 (pow.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) #s(literal 2 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1 binary64)))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
	98.1%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (neg.f64 (pow.f64 (pow.f64 (log.f64 im) #s(literal -1 binary64)) #s(literal -2 binary64)))) (-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
	86.1%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (-.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im)) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
	98.3%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1 binary64)))))) (log.f64 #s(literal 10 binary64)))
	73.9%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) (*.f64 (pow.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal -1 binary64)) (pow.f64 (pow.f64 (log.f64 im) #s(literal -1/2 binary64)) #s(literal -1 binary64)))))) (log.f64 #s(literal 10 binary64)))
	73.5%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 #s(approx (- (pow (* (/ 1/2 im) (* re (/ re im))) 2) (pow (log im) 2)) (neg.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))) (exp.f64 (*.f64 (log.f64 (log.f64 im)) #s(literal 1 binary64)))))) (log.f64 #s(literal 10 binary64)))
	48.1%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (pow.f64 (pow.f64 im #s(literal -1 binary64)) #s(literal -2 binary64)) (log.f64 im) (.f64 (.f64 re re) #s(literal 1/2 binary64))) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
	26.1%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (.f64 im im) (.f64 (.f64 im im) (.f64 (*.f64 im im) (log.f64 im)))) (pow.f64 im #s(literal 4 binary64))))) (log.f64 #s(literal 10 binary64)))
	48.2%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (.f64 im im) (/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 im) #s(literal -1 binary64))) (.f64 (.f64 re re) #s(literal 1/2 binary64))) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
	48.1%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 (.f64 im im) (log.f64 im) (.f64 (*.f64 re re) #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) (pow.f64 (pow.f64 im #s(literal -1 binary64)) #s(literal 2 binary64)))))) (log.f64 #s(literal 10 binary64)))
	48.2%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (fma.f64 im (.f64 im (log.f64 im)) (.f64 (.f64 re re) #s(literal 1/2 binary64))) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
	36.3%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (/.f64 (fma.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) im (.f64 im (.f64 im (.f64 (log.f64 im) im)))) (.f64 im im)) im))) (log.f64 #s(literal 10 binary64)))
	49.8%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (/.f64 (fma.f64 (.f64 im im) (log.f64 im) (.f64 (*.f64 re re) #s(literal 1/2 binary64))) im) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	49.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (/.f64 (fma.f64 (.f64 im im) (log.f64 im) (.f64 (*.f64 re re) #s(literal 1/2 binary64))) im) im))) (log.f64 #s(literal 10 binary64)))
	3.5%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) im) im))) (log.f64 #s(literal 10 binary64)))
	3.0%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	3.0%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
	35.3%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 #s(approx (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) im) (.f64 (fma.f64 im (/.f64 (log.f64 im) (.f64 re re)) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re))) im))) (log.f64 #s(literal 10 binary64)))
	96.4%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 #s(approx (/ (+ (* (* im im) (log im)) (* (* re re) 1/2)) im) (*.f64 (log.f64 im) im)) im))) (log.f64 #s(literal 10 binary64)))
	47.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 #s(approx (+ (* (* im im) (log im)) (* (* re re) 1/2)) (.f64 (.f64 im im) (log.f64 im))) (*.f64 im im)))) (log.f64 #s(literal 10 binary64)))
	3.5%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im)))) (log.f64 #s(literal 10 binary64)))
	3.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	3.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im))))) (log.f64 #s(literal 10 binary64)))
	3.6%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im)))) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 3 651 to 1 277 computations (65% saved)

regimes161.0ms (3.8%)

Memory

5.2MiB live, 145.3MiB allocated; 24ms collecting garbage

Counts

55 → 1

Calls

Call 1

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

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

Calls

8 calls:

35.0ms	(*.f64 im im)
32.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
28.0ms	(+.f64 (.f64 re re) (.f64 im im))
14.0ms	im
13.0ms	re

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes66.0ms (1.5%)

Memory

31.0MiB live, 124.4MiB allocated; 4ms collecting garbage

Counts

28 → 1

Calls

Call 1

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

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes46.0ms (1.1%)

Memory

3.1MiB live, 100.6MiB allocated; 6ms collecting garbage

Counts

16 → 1

Calls

Call 1

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

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes30.0ms (0.7%)

Memory

5.1MiB live, 50.9MiB allocated; 5ms collecting garbage

Counts

11 → 1

Calls

Call 1

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

Outputs

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes17.0ms (0.4%)

Memory

-12.7MiB live, 31.7MiB allocated; 8ms collecting garbage

Counts

3 → 1

Calls

Call 1

Inputs

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

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

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

Outputs

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes13.0ms (0.3%)

Memory

-18.8MiB live, 27.1MiB allocated; 5ms collecting garbage

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

2 → 1

Calls

Call 1

Inputs

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

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

Outputs

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

Calls

8 calls:

4.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	im
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	`re`
3.0%	1	`im`
3.0%	1	`(*.f64 re re)`

Compiler

Compiled 44 to 38 computations (13.6% saved)

simplify35.0ms (0.8%)

Memory

0.2MiB live, 48.7MiB allocated; 13ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	46	147
1	67	147
2	137	147
3	319	147
4	789	147
5	1532	147
6	1922	147
7	1922	147

Stop Event

1×

saturated

Calls

Call 1

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

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

derivations189.0ms (4.4%)

Memory

9.3MiB live, 198.3MiB allocated; 44ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 147 to 45 computations (69.4% saved)

preprocess40.0ms (0.9%)

Memory

18.7MiB live, 111.2MiB allocated; 11ms collecting garbage

Remove

(sort re im)

(abs im)

(abs re)

Compiler

Compiled 402 to 194 computations (51.7% 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%)

analyze125.0ms (2.9%)

sample1.5s (35.4%)

explain169.0ms (3.9%)

preprocess44.0ms (1%)

eval0.0ms (0%)

prune0.0ms (0%)

series16.0ms (0.4%)

rewrite220.0ms (5.1%)

eval32.0ms (0.7%)

prune6.0ms (0.1%)

series116.0ms (2.7%)

rewrite308.0ms (7.2%)

eval43.0ms (1%)

prune18.0ms (0.4%)

series127.0ms (3%)

rewrite216.0ms (5%)

eval80.0ms (1.9%)

prune56.0ms (1.3%)

series72.0ms (1.7%)

rewrite239.0ms (5.6%)

eval135.0ms (3.2%)

prune147.0ms (3.4%)

regimes161.0ms (3.8%)

regimes66.0ms (1.5%)

regimes46.0ms (1.1%)

regimes30.0ms (0.7%)

regimes17.0ms (0.4%)

regimes13.0ms (0.3%)

simplify35.0ms (0.8%)

derivations189.0ms (4.4%)

preprocess40.0ms (0.9%)

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