Metrics for math.log10 on complex, real part

start0.0ms (0%)

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

analyze77.0ms (2%)

Memory

-11.2MiB live, 88.3MiB allocated; 32ms 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)

sample787.0ms (20.8%)

Memory

16.0MiB live, 1 146.4MiB allocated; 133ms collecting garbage

Samples

545.0ms

8 256×

valid

Precisions

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

ival-hypot: 196.0ms (52.8% of total)

ival-log: 131.0ms (35.3% of total)

ival-div!: 42.0ms (11.3% of total)

adjust: 2.0ms (0.5% of total)

Bogosity

explain154.0ms (4.1%)

Memory

-16.3MiB live, 237.5MiB allocated; 75ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
135	-	1	(-6.200454451826081e-162 -1.7218674458547093e-261)	`(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	121	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	121
↳	`(*.f64 re re)`	overflow	64
↳	`(*.f64 im im)`	overflow	79
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	13	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	13
↳	`(*.f64 re re)`	underflow	68
↳	`(*.f64 im im)`	underflow	55

Confusion

	Predicted +	Predicted -
+	134	1
-	0	121

Precision

1.0

Recall

0.9925925925925926

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	134	0	1
-	0	0	121

Precision?

1.0

Recall?

0.9925925925925926

Freqs

test

number	freq
0	122
1	134

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

77.0ms

512×

valid

Compiler

Compiled 110 to 34 computations (69.1% saved)

Precisions

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

ival-mult!: 41.0ms (66.4% of total)

ival-hypot: 12.0ms (19.4% of total)

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

ival-div!: 2.0ms (3.2% of total)

ival-add!: 1.0ms (1.6% of total)

adjust: 0.0ms (0% of total)

preprocess19.0ms (0.5%)

Memory

-11.4MiB live, 35.5MiB allocated; 2ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

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

Stop Event

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

Calls

Call 1

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

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

Symmetry

(abs re)

(abs im)

(sort re im)

Compiler

Compiled 12 to 10 computations (16.7% saved)

eval0.0ms (0%)

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

prune0.0ms (0%)

Memory

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

Alt Table

Click to see full alt table

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

Compiler

Compiled 12 to 10 computations (16.7% saved)

series15.0ms (0.4%)

Memory

29.0MiB live, 29.0MiB 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)

rewrite252.0ms (6.7%)

Memory

6.6MiB live, 362.6MiB allocated; 71ms 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))))

eval31.0ms (0.8%)

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

prune27.0ms (0.7%)

Memory

-35.0MiB live, 21.9MiB allocated; 23ms 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
▶	48.6%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
▶	99.1%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
▶	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶	18.3%	(/.f64 (log.f64 (sqrt.f64 #s(approx (+ (* re re) (* im im)) (.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))))) (log.f64 #s(literal 10 binary64)))
▶	97.5%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
	79.2%	#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)))))

Compiler

Compiled 216 to 160 computations (25.9% saved)

series34.0ms (0.9%)

Memory

20.9MiB live, 68.6MiB allocated; 5ms collecting garbage

Counts

30 → 260

Calls

Call 1

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

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

Calls

6 calls:

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

rewrite277.0ms (7.3%)

Memory

28.0MiB live, 209.8MiB allocated; 67ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	793	7729
0	826	6827
1	4201	6632
0	9878	6350

Stop Event

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

Counts

290 → 432

Calls

Call 1

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

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

eval40.0ms (1.1%)

Memory: -11.0MiB live, 77.5MiB allocated; 8ms collecting garbage
Compiler: Compiled 8 524 to 1 489 computations (82.5% saved)

prune14.0ms (0.4%)

Memory

-33.4MiB live, 26.9MiB allocated; 10ms collecting garbage

Pruning

8 alts after pruning (4 fresh and 4 done)

	Pruned	Kept	Total
New	320	4	324
Fresh	1	0	1
Picked	1	4	5
Done	0	0	0
Total	322	8	330

Accuracy

99.7%

Counts

330 → 8

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	17.8%	(/.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)))
▶	48.7%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	48.6%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
✓	99.1%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
▶	97.5%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	97.5%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶	79.2%	#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)))))

Compiler

Compiled 139 to 109 computations (21.6% saved)

series319.0ms (8.4%)

Memory

45.7MiB live, 417.0MiB allocated; 77ms collecting garbage

Counts

46 → 376

Calls

Call 1

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

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

rewrite259.0ms (6.9%)

Memory

27.5MiB live, 304.1MiB allocated; 75ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1287	14847
0	1352	13375
1	7654	13345
0	8077	12259

Stop Event

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

Counts

422 → 551

Calls

Call 1

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

eval75.0ms (2%)

Memory: -9.8MiB live, 134.8MiB allocated; 35ms collecting garbage
Compiler: Compiled 23 234 to 2 596 computations (88.8% saved)

prune26.0ms (0.7%)

Memory

5.5MiB live, 50.7MiB allocated; 18ms collecting garbage

Pruning

13 alts after pruning (7 fresh and 6 done)

	Pruned	Kept	Total
New	571	7	578
Fresh	0	0	0
Picked	2	2	4
Done	0	4	4
Total	573	13	586

Accuracy

99.8%

Counts

586 → 13

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	48.7%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	48.6%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
▶	47.6%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 #s(approx (+ ( im im) (* re re)) (*.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
▶	84.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 (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)))
✓	99.1%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
✓	97.5%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	97.5%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶	72.2%	(/.f64 #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)))))) (log.f64 #s(literal 10 binary64)))
	79.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (-.f64 (.f64 (.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 re re)) (.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 re re))) (.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))) (-.f64 (.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 re re)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
	79.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (+.f64 (pow.f64 (.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 re re)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64))) (fma.f64 (.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 re re)) (.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 re re)) (-.f64 (.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (.f64 (.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 re re)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))))
▶	25.3%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (/.f64 (fma.f64 (fma.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) (.f64 im im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64)))) (pow.f64 im #s(literal 4 binary64)))))
▶	23.0%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (.f64 (-.f64 (+.f64 (/.f64 (log.f64 im) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (pow.f64 (.f64 im re) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))))) (*.f64 (/.f64 (pow.f64 im #s(literal -4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64))) (pow.f64 re #s(literal 4 binary64)))))

Compiler

Compiled 1 103 to 561 computations (49.1% saved)

series224.0ms (5.9%)

Memory

-25.8MiB live, 363.4MiB allocated; 60ms collecting garbage

Counts

65 → 346

Calls

Call 1

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

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

Calls

6 calls:

Time	Variable		Point	Expression
43.0ms	re	@	0	((/ (* 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)))))) 1/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) im (/ (* re re) (* im im)) (* re re) re (* im im) (* 4 (log im)) 4 (log 10) 10 (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (neg (log 1/10)) (log 1/10) 1/10 (/ (* 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)))))) (+ (* (/ (* (pow re 4) 12) (pow im 4)) -1/48) (* 1/2 (+ (* (neg (log im)) -2) (/ (* re re) (* im im))))) (/ (* (pow re 4) 12) (pow im 4)) (* (pow re 4) 12) (pow re 4) 12 (pow im 4) -1/48 (* 1/2 (+ (* (neg (log im)) -2) (/ (* re re) (* im im)))) (+ (* (neg (log im)) -2) (/ (* re re) (* im im))) (neg (log im)) -2 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (/ (+ (* (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/ (* -1/4 (pow re 4)) (log 10))) (pow im 4)) (+ (* (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/ (* -1/4 (pow re 4)) (log 10))) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/ (log im) (log 10)) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (/ (* -1/4 (pow re 4)) (log 10)) (* -1/4 (pow re 4)) -1/4 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (* (- (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (* (/ (pow im -4) (log 10)) 1/4)) (pow re 4)) (- (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (* (/ (pow im -4) (log 10)) 1/4)) (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (/ (log im) (* (pow re 4) (log 10))) (* (pow re 4) (log 10)) (/ 1/2 (* (pow (* im re) 2) (log 10))) (* (pow (* im re) 2) (log 10)) (pow (* im re) 2) (* im re) 2 (* (/ (pow im -4) (log 10)) 1/4) (/ (pow im -4) (log 10)) (pow im -4) -4 1/4)
40.0ms	im	@	inf	((/ (* 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)))))) 1/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) im (/ (* re re) (* im im)) (* re re) re (* im im) (* 4 (log im)) 4 (log 10) 10 (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (neg (log 1/10)) (log 1/10) 1/10 (/ (* 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)))))) (+ (* (/ (* (pow re 4) 12) (pow im 4)) -1/48) (* 1/2 (+ (* (neg (log im)) -2) (/ (* re re) (* im im))))) (/ (* (pow re 4) 12) (pow im 4)) (* (pow re 4) 12) (pow re 4) 12 (pow im 4) -1/48 (* 1/2 (+ (* (neg (log im)) -2) (/ (* re re) (* im im)))) (+ (* (neg (log im)) -2) (/ (* re re) (* im im))) (neg (log im)) -2 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (/ (+ (* (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/ (* -1/4 (pow re 4)) (log 10))) (pow im 4)) (+ (* (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/ (* -1/4 (pow re 4)) (log 10))) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/ (log im) (log 10)) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (/ (* -1/4 (pow re 4)) (log 10)) (* -1/4 (pow re 4)) -1/4 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (* (- (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (* (/ (pow im -4) (log 10)) 1/4)) (pow re 4)) (- (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (* (/ (pow im -4) (log 10)) 1/4)) (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (/ (log im) (* (pow re 4) (log 10))) (* (pow re 4) (log 10)) (/ 1/2 (* (pow (* im re) 2) (log 10))) (* (pow (* im re) 2) (log 10)) (pow (* im re) 2) (* im re) 2 (* (/ (pow im -4) (log 10)) 1/4) (/ (pow im -4) (log 10)) (pow im -4) -4 1/4)
40.0ms	im	@	0	((/ (* 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)))))) 1/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) im (/ (* re re) (* im im)) (* re re) re (* im im) (* 4 (log im)) 4 (log 10) 10 (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (neg (log 1/10)) (log 1/10) 1/10 (/ (* 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)))))) (+ (* (/ (* (pow re 4) 12) (pow im 4)) -1/48) (* 1/2 (+ (* (neg (log im)) -2) (/ (* re re) (* im im))))) (/ (* (pow re 4) 12) (pow im 4)) (* (pow re 4) 12) (pow re 4) 12 (pow im 4) -1/48 (* 1/2 (+ (* (neg (log im)) -2) (/ (* re re) (* im im)))) (+ (* (neg (log im)) -2) (/ (* re re) (* im im))) (neg (log im)) -2 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (/ (+ (* (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/ (* -1/4 (pow re 4)) (log 10))) (pow im 4)) (+ (* (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/ (* -1/4 (pow re 4)) (log 10))) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/ (log im) (log 10)) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (/ (* -1/4 (pow re 4)) (log 10)) (* -1/4 (pow re 4)) -1/4 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (* (- (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (* (/ (pow im -4) (log 10)) 1/4)) (pow re 4)) (- (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (* (/ (pow im -4) (log 10)) 1/4)) (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (/ (log im) (* (pow re 4) (log 10))) (* (pow re 4) (log 10)) (/ 1/2 (* (pow (* im re) 2) (log 10))) (* (pow (* im re) 2) (log 10)) (pow (* im re) 2) (* im re) 2 (* (/ (pow im -4) (log 10)) 1/4) (/ (pow im -4) (log 10)) (pow im -4) -4 1/4)
34.0ms	im	@	-inf	((/ (* 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)))))) 1/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) im (/ (* re re) (* im im)) (* re re) re (* im im) (* 4 (log im)) 4 (log 10) 10 (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (neg (log 1/10)) (log 1/10) 1/10 (/ (* 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)))))) (+ (* (/ (* (pow re 4) 12) (pow im 4)) -1/48) (* 1/2 (+ (* (neg (log im)) -2) (/ (* re re) (* im im))))) (/ (* (pow re 4) 12) (pow im 4)) (* (pow re 4) 12) (pow re 4) 12 (pow im 4) -1/48 (* 1/2 (+ (* (neg (log im)) -2) (/ (* re re) (* im im)))) (+ (* (neg (log im)) -2) (/ (* re re) (* im im))) (neg (log im)) -2 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (/ (+ (* (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/ (* -1/4 (pow re 4)) (log 10))) (pow im 4)) (+ (* (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/ (* -1/4 (pow re 4)) (log 10))) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/ (log im) (log 10)) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (/ (* -1/4 (pow re 4)) (log 10)) (* -1/4 (pow re 4)) -1/4 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (* (- (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (* (/ (pow im -4) (log 10)) 1/4)) (pow re 4)) (- (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (* (/ (pow im -4) (log 10)) 1/4)) (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (/ (log im) (* (pow re 4) (log 10))) (* (pow re 4) (log 10)) (/ 1/2 (* (pow (* im re) 2) (log 10))) (* (pow (* im re) 2) (log 10)) (pow (* im re) 2) (* im re) 2 (* (/ (pow im -4) (log 10)) 1/4) (/ (pow im -4) (log 10)) (pow im -4) -4 1/4)
29.0ms	re	@	-inf	((/ (* 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)))))) 1/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) im (/ (* re re) (* im im)) (* re re) re (* im im) (* 4 (log im)) 4 (log 10) 10 (/ (* 1/2 (log (+ (* im im) (* re re)))) (neg (log 1/10))) (* 1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (neg (log 1/10)) (log 1/10) 1/10 (/ (* 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)))))) (+ (* (/ (* (pow re 4) 12) (pow im 4)) -1/48) (* 1/2 (+ (* (neg (log im)) -2) (/ (* re re) (* im im))))) (/ (* (pow re 4) 12) (pow im 4)) (* (pow re 4) 12) (pow re 4) 12 (pow im 4) -1/48 (* 1/2 (+ (* (neg (log im)) -2) (/ (* re re) (* im im)))) (+ (* (neg (log im)) -2) (/ (* re re) (* im im))) (neg (log im)) -2 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (/ (+ (* (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/ (* -1/4 (pow re 4)) (log 10))) (pow im 4)) (+ (* (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (* im im)) (/ (* -1/4 (pow re 4)) (log 10))) (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/ (log im) (log 10)) (/ (* 1/2 (* re re)) (log 10)) (* 1/2 (* re re)) (/ (* -1/4 (pow re 4)) (log 10)) (* -1/4 (pow re 4)) -1/4 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (* (- (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (* (/ (pow im -4) (log 10)) 1/4)) (pow re 4)) (- (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (* (/ (pow im -4) (log 10)) 1/4)) (+ (/ (log im) (* (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (/ (log im) (* (pow re 4) (log 10))) (* (pow re 4) (log 10)) (/ 1/2 (* (pow (* im re) 2) (log 10))) (* (pow (* im re) 2) (log 10)) (pow (* im re) 2) (* im re) 2 (* (/ (pow im -4) (log 10)) 1/4) (/ (pow im -4) (log 10)) (pow im -4) -4 1/4)

rewrite308.0ms (8.1%)

Memory

3.3MiB live, 233.5MiB allocated; 30ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1142	15815
0	1243	14502
1	6656	14473
0	8097	13748

Stop Event

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

Counts

411 → 604

Calls

Call 1

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

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

eval104.0ms (2.7%)

Memory: 4.8MiB live, 155.0MiB allocated; 14ms collecting garbage
Compiler: Compiled 50 381 to 3 489 computations (93.1% saved)

prune85.0ms (2.3%)

Memory

-4.7MiB live, 93.2MiB allocated; 10ms collecting garbage

Pruning

23 alts after pruning (17 fresh and 6 done)

	Pruned	Kept	Total
New	748	16	764
Fresh	1	1	2
Picked	4	1	5
Done	1	5	6
Total	754	23	777

Accuracy

99.9%

Counts

777 → 23

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	48.7%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	48.6%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
✓	47.6%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 #s(approx (+ ( im im) (* re re)) (*.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
	97.5%	(/.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 (log.f64 im) #s(literal 6 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 im) #s(literal 4 binary64)) #s(literal 3 binary64))) (fma.f64 (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 (log.f64 im) #s(literal 6 binary64))) (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 (log.f64 im) #s(literal 6 binary64))) (fma.f64 (.f64 (log.f64 im) #s(literal 4 binary64)) (.f64 (log.f64 im) #s(literal 4 binary64)) (.f64 (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 (log.f64 im) #s(literal 6 binary64))) (*.f64 (log.f64 im) #s(literal 4 binary64)))))))) (log.f64 #s(literal 10 binary64)))
	97.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 (.f64 (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 (log.f64 im) #s(literal 6 binary64))) (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 (log.f64 im) #s(literal 6 binary64)))) (.f64 (.f64 (log.f64 im) #s(literal 4 binary64)) (.f64 (log.f64 im) #s(literal 4 binary64)))) (+.f64 (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 (log.f64 im) #s(literal 6 binary64))) (.f64 (log.f64 im) #s(literal 4 binary64)))))) (log.f64 #s(literal 10 binary64)))
	84.3%	(/.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.1%	(/.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 (log.f64 im) #s(literal 6 binary64))) (.f64 #s(literal 4 binary64) (log.f64 im))))) (log.f64 #s(literal 10 binary64)))
	46.1%	(/.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 (fma.f64 (.f64 (log.f64 im) #s(literal 2 binary64)) (.f64 im im) (.f64 re re)) (.f64 im im))))) (log.f64 #s(literal 10 binary64)))
	45.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 (fma.f64 (/.f64 (log.f64 im) (.f64 re re)) #s(literal 6 binary64) (-.f64 (pow.f64 im #s(literal -2 binary64)) (/.f64 (.f64 (log.f64 im) #s(literal 4 binary64)) (.f64 re re)))) (*.f64 re re))))) (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)))
	97.5%	(/.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 (log.f64 im) #s(literal 6 binary64))) (.f64 (log.f64 im) #s(literal 4 binary64)))) #s(literal 1/2 binary64))) (log.f64 #s(literal 1/10 binary64)))
✓	97.5%	(/.f64 (neg.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.0%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	97.5%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
	72.2%	(/.f64 #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)) (.f64 (.f64 im im) (.f64 im im))) #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)))))) (log.f64 #s(literal 10 binary64)))
	97.9%	(/.f64 #s(approx (* 1/2 (- (log (+ (pow re 6) (pow im 6))) (log (+ (pow re 4) (- (pow im 4) (pow (* re im) 2)))))) #s(approx (+ (* (/ (* (pow re 4) 12) (pow im 4)) -1/48) (* 1/2 (+ (* (neg (log im)) -2) (/ (* re re) (* im im))))) (fma.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
	98.0%	(/.f64 #s(approx (* 1/2 (log (+ (* im im) (* re re)))) (fma.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 im))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
	79.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (+.f64 (pow.f64 (.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 re re)) #s(literal 3 binary64)) (pow.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) #s(literal 3 binary64))) (fma.f64 (.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 re re)) (.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 re re)) (-.f64 (.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))) (.f64 (.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal -2 binary64)) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 re re)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))))
	25.3%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (/.f64 (fma.f64 (fma.f64 (.f64 im im) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) (.f64 im im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64)))) (pow.f64 im #s(literal 4 binary64)))))
	25.3%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (/.f64 (fma.f64 (fma.f64 (.f64 im im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) (.f64 im im) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64)))) (.f64 (.f64 im im) (.f64 im im)))))
	25.0%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (/.f64 (fma.f64 #s(approx (+ (* (* im im) (/ (log im) (log 10))) (/ (* 1/2 (* re re)) (log 10))) (/.f64 (.f64 (.f64 im im) (log.f64 im)) (log.f64 #s(literal 10 binary64)))) (.f64 im im) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64)))) (pow.f64 im #s(literal 4 binary64)))))
	23.0%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (.f64 (-.f64 (+.f64 (/.f64 (log.f64 im) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (pow.f64 (.f64 im re) #s(literal 2 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 (/.f64 (pow.f64 im #s(literal -4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
	22.8%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (+ (* (/ (pow im -2) (log 10)) 1/2) (/ (* -1/4 (* re re)) (* (log 10) (pow im 4)))) (* re re)) (/ (log im) (log 10))) (.f64 #s(approx (- (+ (/ (log im) ( (pow re 4) (log 10))) (/ 1/2 (* (pow (* im re) 2) (log 10)))) (* (/ (pow im -4) (log 10)) 1/4)) (/.f64 (log.f64 im) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))))) (pow.f64 re #s(literal 4 binary64)))))

Compiler

Compiled 3 115 to 1 053 computations (66.2% saved)

regimes75.0ms (2%)

Memory

31.2MiB live, 165.0MiB allocated; 10ms collecting garbage

Counts

34 → 1

Calls

Call 1

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

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

Calls

8 calls:

11.0ms	re
10.0ms	(*.f64 re re)
10.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
9.0ms	im
8.0ms	(+.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)

regimes34.0ms (0.9%)

Memory

-24.4MiB live, 78.2MiB allocated; 7ms collecting garbage

Counts

12 → 1

Calls

Call 1

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

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes29.0ms (0.8%)

Memory

-19.0MiB live, 76.0MiB allocated; 3ms collecting garbage

Counts

11 → 1

Calls

Call 1

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

Outputs

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes58.0ms (1.5%)

Memory

-31.8MiB live, 54.1MiB allocated; 73ms collecting garbage

Counts

8 → 1

Calls

Call 1

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

Outputs

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes48.0ms (1.3%)

Memory

-9.4MiB live, 40.5MiB allocated; 5ms collecting garbage

Counts

7 → 1

Calls

Call 1

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

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes10.0ms (0.3%)

Memory

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

Counts

2 → 1

Calls

Call 1

Inputs

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

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes9.0ms (0.2%)

Memory

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

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

1 → 1

Calls

Call 1

Inputs

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

Outputs

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

Calls

8 calls:

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

derivations316.0ms (8.3%)

Memory

-36.9MiB live, 391.0MiB allocated; 21ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 194 to 77 computations (60.3% saved)

preprocess78.0ms (2.1%)

Memory: 16.1MiB live, 109.2MiB allocated; 11ms collecting garbage
Compiler: Compiled 1 576 to 990 computations (37.2% 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%)

analyze77.0ms (2%)

sample787.0ms (20.8%)

explain154.0ms (4.1%)

preprocess19.0ms (0.5%)

eval0.0ms (0%)

prune0.0ms (0%)

series15.0ms (0.4%)

rewrite252.0ms (6.7%)

eval31.0ms (0.8%)

prune27.0ms (0.7%)

series34.0ms (0.9%)

rewrite277.0ms (7.3%)

eval40.0ms (1.1%)

prune14.0ms (0.4%)

series319.0ms (8.4%)

rewrite259.0ms (6.9%)

eval75.0ms (2%)

prune26.0ms (0.7%)

series224.0ms (5.9%)

rewrite308.0ms (8.1%)

eval104.0ms (2.7%)

prune85.0ms (2.3%)

regimes75.0ms (2%)

regimes34.0ms (0.9%)

regimes29.0ms (0.8%)

regimes58.0ms (1.5%)

regimes48.0ms (1.3%)

regimes10.0ms (0.3%)

regimes9.0ms (0.2%)

derivations316.0ms (8.3%)

preprocess78.0ms (2.1%)

end0.0ms (0%)

Profiling

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