Metrics for math.log10 on complex, real part

start0.0ms (0%)

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

analyze76.0ms (1.6%)

Memory

-13.5MiB live, 82.7MiB allocated; 27ms collecting garbage

Algorithm

1×

Search

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

Compiler

Compiled 14 to 9 computations (35.7% saved)

sample1.1s (22.8%)

Memory

22.9MiB live, 1 200.6MiB allocated; 214ms collecting garbage

Samples

820.0ms

8 256×

valid

Precisions

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

ival-log: 232.0ms (44.6% of total)

ival-hypot: 164.0ms (31.5% of total)

ival-div: 115.0ms (22.1% of total)

exact: 5.0ms (1% of total)

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

adjust: 2.0ms (0.4% of total)

Bogosity

explain198.0ms (4.1%)

Memory

23.8MiB live, 217.9MiB allocated; 27ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
138	-	1	(-1.8598624329963746e-286 -8.652148661591521e-159)	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
0	-	0	-	`(log.f64 #s(literal 10 binary64))`
0	-	0	-	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
0	-	0	-	`(*.f64 re re)`
0	-	0	-	`im`
0	-	0	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	0	-	`re`
0	-	0	-	`(*.f64 im im)`
0	-	0	-	`#s(literal 10 binary64)`
0	-	0	-	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`

Explanations

Click to see full explanations table

Operator	Subexpression	Explanation	Count
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	oflow-rescue	116	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	116
↳	`(*.f64 re re)`	overflow	59
↳	`(*.f64 im im)`	overflow	80
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	21	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	21
↳	`(*.f64 re re)`	underflow	68
↳	`(*.f64 im im)`	underflow	66

Confusion

	Predicted +	Predicted -
+	137	1
-	0	118

Precision

1.0

Recall

0.9927536231884058

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	137	0	1
-	0	0	118

Precision?

1.0

Recall?

0.9927536231884058

Freqs

test

number	freq
0	119
1	137

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

121.0ms

512×

valid

Compiler

Compiled 110 to 34 computations (69.1% saved)

Precisions

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

ival-mult: 70.0ms (66.9% of total)

ival-log: 20.0ms (19.1% of total)

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

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

ival-add: 2.0ms (1.9% 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)

preprocess51.0ms (1.1%)

Memory

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

prune0.0ms (0%)

Memory

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

Alt Table

Click to see full alt table

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

Compiler

Compiled 12 to 10 computations (16.7% saved)

series16.0ms (0.3%)

Memory

12.6MiB live, 12.6MiB 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)
1.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)

rewrite201.0ms (4.2%)

Memory

25.5MiB live, 253.7MiB allocated; 44ms 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))))

eval53.0ms (1.1%)

Memory: 15.1MiB live, 59.6MiB allocated; 6ms collecting garbage
Compiler: Compiled 4 158 to 936 computations (77.5% saved)

prune9.0ms (0.2%)

Memory

-26.7MiB live, 20.1MiB allocated; 2ms collecting garbage

Pruning

6 alts after pruning (6 fresh and 0 done)

	Pruned	Kept	Total
New	211	6	217
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	212	6	218

Accuracy

99.7%

Counts

218 → 6

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	47.6%	(/.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)))
▶	89.9%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im))) (log.f64 #s(literal 10 binary64)))
▶	98.1%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶	89.9%	(/.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 172 to 136 computations (20.9% saved)

series85.0ms (1.8%)

Memory

18.1MiB live, 161.7MiB allocated; 21ms collecting garbage

Counts

26 → 171

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

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

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)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ (* re re) im) 1/2) im) (/ (* re re) im) (/ (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) (log im))
18.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)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ (* re re) im) 1/2) im) (/ (* re re) im) (/ (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) (log im))
10.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)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ (* re re) im) 1/2) im) (/ (* re re) im) (/ (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) (log im))
10.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)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ (* re re) im) 1/2) im) (/ (* re re) im) (/ (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) (log im))
9.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)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ (* re re) im) 1/2) im) (/ (* re re) im) (/ (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) (log im))

rewrite201.0ms (4.2%)

Memory

-7.8MiB live, 286.4MiB allocated; 56ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	590	5116
0	623	4541
1	3243	4469
0	8604	4293

Stop Event

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

Counts

197 → 293

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

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

eval81.0ms (1.7%)

Memory: -12.8MiB live, 79.0MiB allocated; 9ms collecting garbage
Compiler: Compiled 7 574 to 1 172 computations (84.5% saved)

prune15.0ms (0.3%)

Memory

-5.7MiB live, 40.0MiB allocated; 3ms collecting garbage

Pruning

12 alts after pruning (9 fresh and 3 done)

	Pruned	Kept	Total
New	287	8	295
Fresh	0	1	1
Picked	2	3	5
Done	0	0	0
Total	289	12	301

Accuracy

99.7%

Counts

301 → 12

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	17.9%	(/.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)))
✓	47.6%	(/.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.9%	(/.f64 (neg.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 1/10 binary64)))
	98.0%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.1%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶	98.9%	(/.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)))
✓	98.1%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
	64.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 (/.f64 (pow.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 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)))
	68.5%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (/.f64 (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (/.f64 (pow.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))) (-.f64 (log.f64 im) (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re (/.f64 re im)))))) (log.f64 #s(literal 10 binary64)))
▶	46.0%	(/.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)))
▶	3.6%	(/.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 569 to 400 computations (29.7% saved)

series242.0ms (5%)

Memory

23.8MiB live, 350.1MiB allocated; 48ms collecting garbage

Counts

48 → 356

Calls

Call 1

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

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

Calls

6 calls:

Time	Variable		Point	Expression
51.0ms	im	@	inf	((/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) 1/2 (* re (/ re 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))) (+ (* (* re (/ re im)) 1/2) im) (/ (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) (* re re) (/ (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (log 10)) (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))))) (log (+ (pow re 6) (pow im 6))) (+ (pow re 6) (pow im 6)) (pow re 6) 6 (pow im 6) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))) (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))) (pow re 4) 4 (- (pow im 4) (pow (* re im) 2)) (pow im 4) (pow (* re im) 2) (* re im) 2)
44.0ms	re	@	inf	((/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) 1/2 (* re (/ re 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))) (+ (* (* re (/ re im)) 1/2) im) (/ (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) (* re re) (/ (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (log 10)) (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))))) (log (+ (pow re 6) (pow im 6))) (+ (pow re 6) (pow im 6)) (pow re 6) 6 (pow im 6) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))) (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))) (pow re 4) 4 (- (pow im 4) (pow (* re im) 2)) (pow im 4) (pow (* re im) 2) (* re im) 2)
43.0ms	im	@	0	((/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) 1/2 (* re (/ re 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))) (+ (* (* re (/ re im)) 1/2) im) (/ (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) (* re re) (/ (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (log 10)) (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))))) (log (+ (pow re 6) (pow im 6))) (+ (pow re 6) (pow im 6)) (pow re 6) 6 (pow im 6) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))) (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))) (pow re 4) 4 (- (pow im 4) (pow (* re im) 2)) (pow im 4) (pow (* re im) 2) (* re im) 2)
43.0ms	re	@	0	((/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) 1/2 (* re (/ re 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))) (+ (* (* re (/ re im)) 1/2) im) (/ (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) (* re re) (/ (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (log 10)) (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))))) (log (+ (pow re 6) (pow im 6))) (+ (pow re 6) (pow im 6)) (pow re 6) 6 (pow im 6) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))) (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))) (pow re 4) 4 (- (pow im 4) (pow (* re im) 2)) (pow im 4) (pow (* re im) 2) (* re im) 2)
36.0ms	im	@	-inf	((/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) im re (log 1/10) 1/10 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (* (/ 1/2 im) (* re (/ re im))) (/ 1/2 im) 1/2 (* re (/ re 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))) (+ (* (* re (/ re im)) 1/2) im) (/ (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) (* re re) (/ (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (log 10)) (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))))) (log (+ (pow re 6) (pow im 6))) (+ (pow re 6) (pow im 6)) (pow re 6) 6 (pow im 6) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))) (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))) (pow re 4) 4 (- (pow im 4) (pow (* re im) 2)) (pow im 4) (pow (* re im) 2) (* re im) 2)

rewrite1.4s (29%)

Memory

-264.1MiB live, 368.8MiB allocated; 1.6s collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1174	13134
0	1234	11555
1	6636	11486
0	8214	11116

Stop Event

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

Counts

404 → 554

Calls

Call 1

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

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

eval91.0ms (1.9%)

Memory: 38.6MiB live, 84.0MiB allocated; 6ms collecting garbage
Compiler: Compiled 21 377 to 2 645 computations (87.6% saved)

prune61.0ms (1.3%)

Memory

-20.6MiB live, 72.2MiB allocated; 14ms collecting garbage

Pruning

22 alts after pruning (16 fresh and 6 done)

	Pruned	Kept	Total
New	550	13	563
Fresh	1	3	4
Picked	2	3	5
Done	0	3	3
Total	553	22	575

Accuracy

99.7%

Counts

575 → 22

Alt Table

Click to see full alt table

Status	Accuracy	Program
	17.9%	(/.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))))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	47.6%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
▶	81.7%	(/.f64 (.f64 #s(literal 1/2 binary64) #s(approx (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow ( re im) 2))))) (-.f64 (fma.f64 #s(literal 6 binary64) (log.f64 im) (/.f64 (.f64 re re) (.f64 im im))) (*.f64 #s(literal 4 binary64) (log.f64 im))))) (log.f64 #s(literal 10 binary64)))
▶	47.6%	(/.f64 (neg.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (log.f64 #s(literal 1/10 binary64)))
✓	99.0%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
▶	98.9%	(/.f64 (neg.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 1/10 binary64)))
	98.0%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
	3.6%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* im im) (* re re)))) #s(approx (+ (* (/ 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)))
✓	98.9%	(/.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)))
✓	98.1%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
	64.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 (/.f64 (pow.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 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)))
	45.8%	(/.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)))
	47.5%	(/.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.4%	(/.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.4%	(/.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)))
	45.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)))
▶	2.8%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
	3.4%	(/.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.6%	(/.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.6%	(/.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 #s(literal 1/2 binary64) im) re) (/.f64 re im)))) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 1 213 to 818 computations (32.6% saved)

series67.0ms (1.4%)

Memory

33.9MiB live, 125.9MiB allocated; 11ms collecting garbage

Counts

41 → 342

Calls

Call 1

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

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

Calls

6 calls:

Time	Variable		Point	Expression
16.0ms	im	@	0	((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (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)) (* (/ (* re re) (* im im)) 1/2) (/ (* re re) (* im im)) (* re re) (* im im) (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) im) (* (* re re) 1/2) (/ (neg (* 1/2 (log (+ (* re re) (* im im))))) (log 1/10)) (neg (* 1/2 (log (+ (* re re) (* im im))))) (* 1/2 (log (+ (* re re) (* im im)))) (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (log 10)) (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))))) (- (+ (* 6 (log im)) (/ (* re re) (* im im))) (* 4 (log im))) (+ (* 6 (log im)) (/ (* re re) (* im im))) 6 (log im) (* 4 (log im)) 4)
14.0ms	im	@	inf	((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (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)) (* (/ (* re re) (* im im)) 1/2) (/ (* re re) (* im im)) (* re re) (* im im) (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) im) (* (* re re) 1/2) (/ (neg (* 1/2 (log (+ (* re re) (* im im))))) (log 1/10)) (neg (* 1/2 (log (+ (* re re) (* im im))))) (* 1/2 (log (+ (* re re) (* im im)))) (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (log 10)) (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))))) (- (+ (* 6 (log im)) (/ (* re re) (* im im))) (* 4 (log im))) (+ (* 6 (log im)) (/ (* re re) (* im im))) 6 (log im) (* 4 (log im)) 4)
11.0ms	im	@	-inf	((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (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)) (* (/ (* re re) (* im im)) 1/2) (/ (* re re) (* im im)) (* re re) (* im im) (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) im) (* (* re re) 1/2) (/ (neg (* 1/2 (log (+ (* re re) (* im im))))) (log 1/10)) (neg (* 1/2 (log (+ (* re re) (* im im))))) (* 1/2 (log (+ (* re re) (* im im)))) (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (log 10)) (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))))) (- (+ (* 6 (log im)) (/ (* re re) (* im im))) (* 4 (log im))) (+ (* 6 (log im)) (/ (* re re) (* im im))) 6 (log im) (* 4 (log im)) 4)
7.0ms	re	@	inf	((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (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)) (* (/ (* re re) (* im im)) 1/2) (/ (* re re) (* im im)) (* re re) (* im im) (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) im) (* (* re re) 1/2) (/ (neg (* 1/2 (log (+ (* re re) (* im im))))) (log 1/10)) (neg (* 1/2 (log (+ (* re re) (* im im))))) (* 1/2 (log (+ (* re re) (* im im)))) (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (log 10)) (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))))) (- (+ (* 6 (log im)) (/ (* re re) (* im im))) (* 4 (log im))) (+ (* 6 (log im)) (/ (* re re) (* im im))) 6 (log im) (* 4 (log im)) 4)
6.0ms	re	@	0	((/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (* re (/ re im)) 1/2) im) (* re (/ re im)) re (/ re im) im 1/2 (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)) (* (/ (* re re) (* im im)) 1/2) (/ (* re re) (* im im)) (* re re) (* im im) (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) im) (* (* re re) 1/2) (/ (neg (* 1/2 (log (+ (* re re) (* im im))))) (log 1/10)) (neg (* 1/2 (log (+ (* re re) (* im im))))) (* 1/2 (log (+ (* re re) (* im im)))) (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (log 10)) (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2))))) (- (+ (* 6 (log im)) (/ (* re re) (* im im))) (* 4 (log im))) (+ (* 6 (log im)) (/ (* re re) (* im im))) 6 (log im) (* 4 (log im)) 4)

rewrite228.0ms (4.7%)

Memory

-25.2MiB live, 302.0MiB allocated; 47ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1147	13399
0	1199	12170
1	6716	12064
0	8316	10890

Stop Event

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

Counts

383 → 490

Calls

Call 1

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

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

eval76.0ms (1.6%)

Memory: 2.6MiB live, 142.9MiB allocated; 38ms collecting garbage
Compiler: Compiled 19 954 to 2 339 computations (88.3% saved)

prune52.0ms (1.1%)

Memory

13.0MiB live, 102.1MiB allocated; 18ms collecting garbage

Pruning

27 alts after pruning (20 fresh and 7 done)

	Pruned	Kept	Total
New	507	12	519
Fresh	3	8	11
Picked	3	2	5
Done	1	5	6
Total	514	27	541

Accuracy

99.8%

Counts

541 → 27

Alt Table

Click to see full alt table

Status	Accuracy	Program
	98.4%	(/.f64 (.f64 #s(literal 1/2 binary64) #s(approx (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow ( re im) 2))))) (/.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 #s(literal 6 binary64) (log.f64 im))) #s(literal 3 binary64)) (pow.f64 (.f64 #s(literal 4 binary64) (log.f64 im)) #s(literal 3 binary64))) (fma.f64 (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 #s(literal 6 binary64) (log.f64 im))) (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 #s(literal 6 binary64) (log.f64 im))) (fma.f64 (.f64 #s(literal 4 binary64) (log.f64 im)) (.f64 #s(literal 4 binary64) (log.f64 im)) (.f64 (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 #s(literal 6 binary64) (log.f64 im))) (*.f64 #s(literal 4 binary64) (log.f64 im)))))))) (log.f64 #s(literal 10 binary64)))
	81.6%	(/.f64 (.f64 #s(literal 1/2 binary64) #s(approx (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow ( re im) 2))))) (-.f64 (fma.f64 #s(literal 6 binary64) (log.f64 im) (/.f64 (.f64 re re) (.f64 im im))) (*.f64 #s(literal 4 binary64) (log.f64 im))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
	97.7%	(/.f64 (.f64 #s(literal 1/2 binary64) #s(approx (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow ( re im) 2))))) (-.f64 #s(approx (+ (* 6 (log im)) (/ (* re re) (* im im))) (.f64 #s(literal 6 binary64) (log.f64 im))) (.f64 #s(literal 4 binary64) (log.f64 im))))) (log.f64 #s(literal 10 binary64)))
	3.6%	(/.f64 (.f64 #s(literal 1/2 binary64) #s(approx (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow ( re im) 2))))) #s(approx (- (+ (* 6 (log im)) (/ (* re re) (* im im))) (* 4 (log im))) (*.f64 (/.f64 re im) (/.f64 re im))))) (log.f64 #s(literal 10 binary64)))
	47.6%	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
	98.4%	(/.f64 (neg.f64 (.f64 #s(approx (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow ( re im) 2))))) (-.f64 (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 #s(literal 6 binary64) (log.f64 im))) (.f64 #s(literal 4 binary64) (log.f64 im)))) #s(literal 1/2 binary64))) (log.f64 #s(literal 1/10 binary64)))
✓	99.0%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
✓	98.9%	(/.f64 (neg.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 1/10 binary64)))
	98.0%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) #s(approx (+ (* (* re (/ re im)) 1/2) im) im)))) (log.f64 #s(literal 1/10 binary64)))
	3.6%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (.f64 (/.f64 re im) re) (/.f64 #s(literal 1/2 binary64) im))))) (log.f64 #s(literal 1/10 binary64)))
	3.6%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* im im) (* re re)))) #s(approx (+ (* (/ 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)))
✓	98.9%	(/.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)))
✓	98.1%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
	64.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 (/.f64 (pow.f64 (.f64 (.f64 re re) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 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)))
	45.8%	(/.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)))
	47.5%	(/.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.4%	(/.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))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
	3.4%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (/.f64 (/.f64 (.f64 re (.f64 re #s(literal 1/2 binary64))) im) im))) (log.f64 #s(literal 10 binary64)))
	3.4%	(/.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)))
	45.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)))
	2.8%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	2.8%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))
	3.4%	(/.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.6%	(/.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 #s(literal 1/2 binary64) im) re) (/.f64 re im)))) (log.f64 #s(literal 10 binary64)))
	3.2%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (/ 1/2 im) (/ (* re re) im)) (log im)) (.f64 (.f64 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 2 313 to 879 computations (62% saved)

regimes91.0ms (1.9%)

Memory

6.8MiB live, 109.7MiB allocated; 21ms collecting garbage

Counts

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

23.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
11.0ms	(+.f64 (.f64 re re) (.f64 im im))
10.0ms	re
10.0ms	im
9.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))

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)

regimes60.0ms (1.2%)

Memory

-9.4MiB live, 84.6MiB allocated; 3ms collecting garbage

Counts

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

Outputs
(/.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)))

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes44.0ms (0.9%)

Memory

15.2MiB live, 64.0MiB allocated; 3ms collecting garbage

Counts

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

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes32.0ms (0.7%)

Memory

3.2MiB live, 50.3MiB allocated; 2ms collecting garbage

Counts

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

5.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
4.0ms	re
4.0ms	im
4.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
4.0ms	(*.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)

regimes15.0ms (0.3%)

Memory

-22.4MiB live, 24.8MiB allocated; 1ms collecting garbage

Counts

4 → 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 re (/.f64 re (*.f64 im im))) #s(literal 1/2 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 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 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 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64)))) (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 #s(literal 1/2 binary64) im) re) (/.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 #s(literal 1/2 binary64) im) re) (/.f64 re im)))) (log.f64 #s(literal 10 binary64)))

Calls

8 calls:

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

Results

Accuracy	Segments	Branch
3.6%	1	`(*.f64 re re)`
3.6%	1	`re`
3.6%	1	`(*.f64 im im)`
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	`im`

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes12.0ms (0.3%)

Memory

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

Accuracy

Total -0.2b remaining (-0.3%)

Threshold costs -0.2b (-0.3%)

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

simplify30.0ms (0.6%)

Memory

-31.4MiB live, 15.9MiB allocated; 1ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	44	147
1	63	147
2	132	147
3	319	147
4	789	147
5	1538	147
6	1930	147
7	1930	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 (+ (* 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 #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 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) (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 (+ (* 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 #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 re (/.f64 re (*.f64 im im))) #s(literal 1/2 binary64)))) (log.f64 #s(literal 10 binary64)))

derivations199.0ms (4.1%)

Memory

17.0MiB live, 159.6MiB allocated; 6ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 147 to 45 computations (69.4% saved)

preprocess32.0ms (0.7%)

Memory

2.6MiB live, 49.0MiB allocated; 3ms collecting garbage

Remove

(sort re im)

(abs im)

(abs re)

Compiler

Compiled 360 to 152 computations (57.8% saved)

end0.0ms (0%)

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

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

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

start0.0ms (0%)

analyze76.0ms (1.6%)

sample1.1s (22.8%)

explain198.0ms (4.1%)

preprocess51.0ms (1.1%)

eval0.0ms (0%)

prune0.0ms (0%)

series16.0ms (0.3%)

rewrite201.0ms (4.2%)

eval53.0ms (1.1%)

prune9.0ms (0.2%)

series85.0ms (1.8%)

rewrite201.0ms (4.2%)

eval81.0ms (1.7%)

prune15.0ms (0.3%)

series242.0ms (5%)

rewrite1.4s (29%)

eval91.0ms (1.9%)

prune61.0ms (1.3%)

series67.0ms (1.4%)

rewrite228.0ms (4.7%)

eval76.0ms (1.6%)

prune52.0ms (1.1%)

regimes91.0ms (1.9%)

regimes60.0ms (1.2%)

regimes44.0ms (0.9%)

regimes32.0ms (0.7%)

regimes15.0ms (0.3%)

regimes12.0ms (0.3%)

simplify30.0ms (0.6%)

derivations199.0ms (4.1%)

preprocess32.0ms (0.7%)

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